Mercurial > octave

annotate libinterp/corefcn/rand.cc @ 29358:0a5b15007766 stable

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update Octave Project Developers copyright for the new year In files that have the "Octave Project Developers" copyright notice, update for 2021.
author John W. Eaton <jwe@octave.org>
date Wed, 10 Feb 2021 09:52:15 -0500
parents bd51beb6205e
children 7854d5752dd2
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
27923
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
1 /////////////////////////////////////////////////////////////////////////*
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
2 //
29358
0a5b15007766 update Octave Project Developers copyright for the new year
John W. Eaton <jwe@octave.org>
parents: 27923
diff changeset
3 // Copyright (C) 1996-2021 The Octave Project Developers
27923
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
4 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
5 // See the file COPYRIGHT.md in the top-level directory of this
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
6 // distribution or <https://octave.org/copyright/>.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
7 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
8 // This file is part of Octave.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
9 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
10 // Octave is free software: you can redistribute it and/or modify it
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
11 // under the terms of the GNU General Public License as published by
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
12 // the Free Software Foundation, either version 3 of the License, or
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
13 // (at your option) any later version.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
14 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
15 // Octave is distributed in the hope that it will be useful, but
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
16 // WITHOUT ANY WARRANTY; without even the implied warranty of
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
18 // GNU General Public License for more details.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
19 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
20 // You should have received a copy of the GNU General Public License
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
21 // along with Octave; see the file COPYING. If not, see
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
22 // <https://www.gnu.org/licenses/>.
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
23 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
24 ////////////////////////////////////////////////////////////////////////
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
25
21724
aba2e6293dd8 use "#if ..." consistently instead of "#ifdef" and "#ifndef"
John W. Eaton <jwe@octave.org>
parents: 21580
diff changeset
26 #if defined (HAVE_CONFIG_H)
21301
40de9f8f23a6 Use '#include "config.h"' rather than <config.h>.
Rik <rik@octave.org>
parents: 21234
diff changeset
27 # include "config.h"
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
28 #endif
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
29
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
30 #include <ctime>
22150
c4901d7a2d7d Remove check for std::tr1::unordered_map because we depend on C++11.
Carnë Draug <carandraug@octave.org>
parents: 21968
diff changeset
31 #include <unordered_map>
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
32 #include <string>
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
33
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
34 #include "f77-fcn.h"
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
35 #include "lo-mappers.h"
4307
fd034cd46aea [project @ 2003-01-24 19:20:50 by jwe]
jwe
parents: 4153
diff changeset
36 #include "oct-rand.h"
4153
6b96ce9f5743 [project @ 2002-11-06 20:38:49 by jwe]
jwe
parents: 3887
diff changeset
37 #include "quit.h"
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
38
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14854
diff changeset
39 #include "defun.h"
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
40 #include "error.h"
21100
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme.
Rik <rik@octave.org>
parents: 21041
diff changeset
41 #include "errwarn.h"
20940
48b2ad5ee801 maint: Rename oct-obj.[cc|h] to ovl.[cc|h] for clarity.
Rik <rik@octave.org>
parents: 20894
diff changeset
42 #include "ovl.h"
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
43 #include "unwind-prot.h"
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
44 #include "utils.h"
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
45 #include "ov-re-mat.h"
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
46
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
47 /*
24816
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
48 %% Restore all rand* "seed" and "state" values in order, so that the
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
49 %% new "state" algorithm remains active after these tests complete.
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
50 %!function restore_rand_states (seed, state)
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
51 %! rand ("seed", seed.rand);
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
52 %! rande ("seed", seed.rande);
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
53 %! randg ("seed", seed.randg);
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
54 %! randn ("seed", seed.randn);
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
55 %! randp ("seed", seed.randp);
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
56 %! rand ("state", state.rand);
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
57 %! rande ("state", state.rande);
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
58 %! randg ("state", state.randg);
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
59 %! randn ("state", state.randn);
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
60 %! randp ("state", state.randp);
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
61 %!endfunction
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
62
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
63 %!shared __random_statistical_tests__, old_seed, old_state, restore_state
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
64 %! ## Flag whether the statistical tests should be run in "make check" or not
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
65 %! __random_statistical_tests__ = 0;
24816
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
66 %! ## Save and restore the states of each of the random number generators
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
67 %! ## that are tested by the unit tests in this file.
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
68 %! old_seed.rand = rand ("seed");
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
69 %! old_seed.rande = rande ("seed");
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
70 %! old_seed.randg = randg ("seed");
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
71 %! old_seed.randn = randn ("seed");
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
72 %! old_seed.randp = randp ("seed");
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
73 %! old_state.rand = rand ("state");
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
74 %! old_state.rande = rande ("state");
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
75 %! old_state.randg = randg ("state");
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
76 %! old_state.randn = randn ("state");
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
77 %! old_state.randp = randp ("state");
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
78 %! restore_state = onCleanup (@() restore_rand_states (old_seed, old_state));
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
79 */
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
80
4307
fd034cd46aea [project @ 2003-01-24 19:20:50 by jwe]
jwe
parents: 4153
diff changeset
81 static octave_value
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
82 do_rand (const octave_value_list& args, int nargin, const char *fcn,
10782
d1f920d1ce0c simplify code in rand.cc
Jaroslav Hajek <highegg@gmail.com>
parents: 10709
diff changeset
83 const std::string& distribution, bool additional_arg = false)
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
84 {
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
85 NDArray a;
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
86 int idx = 0;
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
87 bool is_single = false;
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
88
14846
460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents: 14706
diff changeset
89 if (nargin > 0 && args(nargin-1).is_string ())
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
90 {
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
91 std::string s_arg = args(nargin-1).string_value ();
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
92
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
93 if (s_arg == "single")
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
94 {
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
95 is_single = true;
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
96 nargin--;
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
97 }
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
98 else if (s_arg == "double")
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
99 nargin--;
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
100 }
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
101
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
102 if (additional_arg)
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
103 {
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
104 if (nargin == 0)
20831
35241c4b696c eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents: 20801
diff changeset
105 error ("%s: at least one argument is required", fcn);
14846
460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents: 14706
diff changeset
106 else if (args(0).is_string ())
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
107 additional_arg = false;
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
108 else
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
109 {
20711
7b608fadc663 Make error messages more specific about the variable and problem encountered.
Rik <rik@octave.org>
parents: 20704
diff changeset
110 a = args(0).xarray_value ("%s: dimension must be a scalar integer", fcn);
20704
571508c1ed06 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20687
diff changeset
111
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
112 idx++;
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
113 nargin--;
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
114 }
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
115 }
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
116
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
117 octave_value retval;
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
118 dim_vector dims;
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
119
21743
f4d7d0eb5b0c use namespace for unwind_protect class
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
120 octave::unwind_protect frame;
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
121 // Restore current distribution on any exit.
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
122 frame.add_fcn (octave::rand::distribution,
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
123 octave::rand::distribution ());
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
124
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
125 octave::rand::distribution (distribution);
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
126
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
127 switch (nargin)
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
128 {
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
129 case 0:
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
130 {
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
131 if (additional_arg)
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
132 dims = a.dims ();
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
133 else
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
134 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
135 dims.resize (2);
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
136
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
137 dims(0) = 1;
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
138 dims(1) = 1;
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
139 }
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
140
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
141 goto gen_matrix;
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
142 }
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
143 break;
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
144
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
145 case 1:
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
146 {
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
147 octave_value tmp = args(idx);
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
148
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
149 if (tmp.is_string ())
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
150 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
151 std::string s_arg = tmp.string_value ();
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
152
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
153 if (s_arg == "dist")
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
154 retval = octave::rand::distribution ();
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
155 else if (s_arg == "seed")
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
156 retval = octave::rand::seed ();
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
157 else if (s_arg == "state" || s_arg == "twister")
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
158 retval = octave::rand::state (fcn);
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
159 else if (s_arg == "uniform")
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
160 octave::rand::uniform_distribution ();
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
161 else if (s_arg == "normal")
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
162 octave::rand::normal_distribution ();
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
163 else if (s_arg == "exponential")
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
164 octave::rand::exponential_distribution ();
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
165 else if (s_arg == "poisson")
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
166 octave::rand::poisson_distribution ();
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
167 else if (s_arg == "gamma")
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
168 octave::rand::gamma_distribution ();
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
169 else
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
170 error ("%s: unrecognized string argument", fcn);
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
171 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
172 else if (tmp.is_scalar_type ())
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
173 {
27249
84cdeeaf0dce Accept only integers for single input form of rand (bug #56609).
Rik <rik@octave.org>
parents: 26376
diff changeset
174 octave_idx_type n = tmp.idx_type_value (true);
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
175
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
176 dims.resize (2);
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
177
27249
84cdeeaf0dce Accept only integers for single input form of rand (bug #56609).
Rik <rik@octave.org>
parents: 26376
diff changeset
178 dims(0) = dims(1) = n;
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
179
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
180 goto gen_matrix;
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
181 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
182 else if (tmp.is_range ())
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
183 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
184 Range r = tmp.range_value ();
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
185
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
186 if (! r.all_elements_are_ints ())
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
187 error ("%s: all elements of range must be integers", fcn);
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
188
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
189 octave_idx_type n = r.numel ();
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
190
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
191 dims.resize (n);
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
192
21782
2aef506f3fec use namespace for lo-mappers.h functions
John W. Eaton <jwe@octave.org>
parents: 21743
diff changeset
193 octave_idx_type base = octave::math::nint_big (r.base ());
2aef506f3fec use namespace for lo-mappers.h functions
John W. Eaton <jwe@octave.org>
parents: 21743
diff changeset
194 octave_idx_type incr = octave::math::nint_big (r.inc ());
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
195
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
196 for (octave_idx_type i = 0; i < n; i++)
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
197 {
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
198 // Negative dimensions treated as zero for Matlab compatibility
23450
855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents: 23220
diff changeset
199 dims(i) = (base >= 0 ? base : 0);
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
200 base += incr;
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
201 }
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
202
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
203 goto gen_matrix;
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
204 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
205 else if (tmp.is_matrix_type ())
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
206 {
25927
d6581134daaa Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension in a dimension vector (bug #54781).
Rik <rik@octave.org>
parents: 25926
diff changeset
207 Array<octave_idx_type> iv;
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
208
20743
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
209 try
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
210 {
25927
d6581134daaa Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension in a dimension vector (bug #54781).
Rik <rik@octave.org>
parents: 25926
diff changeset
211 iv = tmp.octave_idx_type_vector_value (true);
20743
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
212 }
22327
d0562b3159c7 move more classes inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 22323
diff changeset
213 catch (octave::execution_exception& e)
20743
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
214 {
20756
200ae1d650b7 propagate octave_execution_exception objects through try/catch blocks
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
215 error (e, "%s: dimensions must be a scalar or array of integers", fcn);
20743
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
216 }
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
217
20743
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
218 octave_idx_type len = iv.numel ();
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
219
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
220 dims.resize (len);
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
221
20743
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
222 for (octave_idx_type i = 0; i < len; i++)
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
223 {
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
224 // Negative dimensions treated as zero for Matlab compatibility
20743
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
225 octave_idx_type elt = iv(i);
23450
855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents: 23220
diff changeset
226 dims(i) = (elt >=0 ? elt : 0);
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
227 }
20743
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
228
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20711
diff changeset
229 goto gen_matrix;
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
230 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
231 else
21129
228b65504557 maint: Eliminate useless statements after err_XXX.
Rik <rik@octave.org>
parents: 21127
diff changeset
232 err_wrong_type_arg ("rand", tmp);
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
233 }
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
234 break;
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
235
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
236 default:
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
237 {
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
238 octave_value tmp = args(idx);
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
239
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
240 if (nargin == 2 && tmp.is_string ())
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
241 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
242 std::string ts = tmp.string_value ();
5164
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe]
jwe
parents: 4665
diff changeset
243
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
244 if (ts == "seed")
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
245 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
246 if (args(idx+1).is_real_scalar ())
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
247 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
248 double d = args(idx+1).double_value ();
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
249
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
250 octave::rand::seed (d);
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
251 }
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11553
diff changeset
252 else if (args(idx+1).is_string ()
14846
460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents: 14706
diff changeset
253 && args(idx+1).string_value () == "reset")
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
254 octave::rand::reset ();
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
255 else
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
256 error ("%s: seed must be a real scalar", fcn);
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
257 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
258 else if (ts == "state" || ts == "twister")
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
259 {
10709
92a85ed5b86e Don't special case color_property type when emitting factory default (bug #30118)
David Bateman <dbateman@free.fr>
parents: 10687
diff changeset
260 if (args(idx+1).is_string ()
14846
460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents: 14706
diff changeset
261 && args(idx+1).string_value () == "reset")
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
262 octave::rand::reset (fcn);
10709
92a85ed5b86e Don't special case color_property type when emitting factory default (bug #30118)
David Bateman <dbateman@free.fr>
parents: 10687
diff changeset
263 else
92a85ed5b86e Don't special case color_property type when emitting factory default (bug #30118)
David Bateman <dbateman@free.fr>
parents: 10687
diff changeset
264 {
27277
db687716fed6 style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents: 27249
diff changeset
265 ColumnVector s
db687716fed6 style fixes: generally aim to break long lines before operators, not after
John W. Eaton <jwe@octave.org>
parents: 27249
diff changeset
266 = ColumnVector (args(idx+1).vector_value (false, true));
25946
85f499b88c43 maint: Strip trailing whitespace from source files.
John W. Eaton <jwe@octave.org>
parents: 25651
diff changeset
267
25651
c759aa39c23a Produce same random number stream for "state" initialized to Inf (bug #54342).
Rik <rik@octave.org>
parents: 25143
diff changeset
268 // Backwards compatibility with previous versions of
c759aa39c23a Produce same random number stream for "state" initialized to Inf (bug #54342).
Rik <rik@octave.org>
parents: 25143
diff changeset
269 // Octave which mapped Inf to 0.
c759aa39c23a Produce same random number stream for "state" initialized to Inf (bug #54342).
Rik <rik@octave.org>
parents: 25143
diff changeset
270 for (octave_idx_type i = 0; i < s.numel (); i++)
c759aa39c23a Produce same random number stream for "state" initialized to Inf (bug #54342).
Rik <rik@octave.org>
parents: 25143
diff changeset
271 if (octave::math::isinf (s.xelem (i)))
c759aa39c23a Produce same random number stream for "state" initialized to Inf (bug #54342).
Rik <rik@octave.org>
parents: 25143
diff changeset
272 s.xelem (i) = 0.0;
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
273
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
274 octave::rand::state (s, fcn);
10709
92a85ed5b86e Don't special case color_property type when emitting factory default (bug #30118)
David Bateman <dbateman@free.fr>
parents: 10687
diff changeset
275 }
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
276 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
277 else
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
278 error ("%s: unrecognized string argument", fcn);
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
279 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
280 else
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
281 {
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
282 dims.resize (nargin);
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
283
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
284 for (int i = 0; i < nargin; i++)
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
285 {
25926
373fe1608f7c Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension (bug #54781).
Rik <rik@octave.org>
parents: 25828
diff changeset
286 octave_idx_type elt = args(idx+i).idx_type_value (true);
20704
571508c1ed06 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20687
diff changeset
287
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
288 // Negative dimensions treated as zero for Matlab compatibility
23450
855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents: 23220
diff changeset
289 dims(i) = (elt >= 0 ? elt : 0);
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
290 }
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
291
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
292 goto gen_matrix;
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
293 }
4543
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
294 }
79df15d4470c [project @ 2003-10-18 03:53:52 by jwe]
jwe
parents: 4307
diff changeset
295 break;
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
296 }
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
297
21170
1edaf1ee65eb maint: Replace some uses of goto in libinterp.
Rik <rik@octave.org>
parents: 21129
diff changeset
298 // No "goto gen_matrix" in code path. Must be done processing.
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
299 return retval;
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
300
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
301 gen_matrix:
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
302
5355
cf44c749ba52 [project @ 2005-05-18 11:43:37 by jwe]
jwe
parents: 5307
diff changeset
303 dims.chop_trailing_singletons ();
cf44c749ba52 [project @ 2005-05-18 11:43:37 by jwe]
jwe
parents: 5307
diff changeset
304
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
305 if (is_single)
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
306 {
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
307 if (additional_arg)
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
308 {
20232
a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents: 20228
diff changeset
309 if (a.numel () == 1)
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
310 return octave::rand::float_nd_array (dims, a(0));
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
311 else
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
312 {
14846
460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents: 14706
diff changeset
313 if (a.dims () != dims)
20831
35241c4b696c eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents: 20801
diff changeset
314 error ("%s: mismatch in argument size", fcn);
35241c4b696c eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents: 20801
diff changeset
315
20232
a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents: 20228
diff changeset
316 octave_idx_type len = a.numel ();
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
317 FloatNDArray m (dims);
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
318 float *v = m.fortran_vec ();
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
319
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
320 for (octave_idx_type i = 0; i < len; i++)
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
321 v[i] = octave::rand::float_scalar (a(i));
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
322
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
323 return m;
10154
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
324 }
40dfc0c99116 DLD-FUNCTIONS/*.cc: untabify
John W. Eaton <jwe@octave.org>
parents: 10066
diff changeset
325 }
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
326 else
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
327 return octave::rand::float_nd_array (dims);
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
328 }
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
329 else
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
330 {
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
331 if (additional_arg)
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
332 {
20232
a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents: 20228
diff changeset
333 if (a.numel () == 1)
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
334 return octave::rand::nd_array (dims, a(0));
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
335 else
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
336 {
14846
460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists.
Rik <octave@nomad.inbox5.com>
parents: 14706
diff changeset
337 if (a.dims () != dims)
20831
35241c4b696c eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents: 20801
diff changeset
338 error ("%s: mismatch in argument size", fcn);
35241c4b696c eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents: 20801
diff changeset
339
20232
a9574e3c6e9e Deprecate Array::length() and Sparse::length() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents: 20228
diff changeset
340 octave_idx_type len = a.numel ();
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
341 NDArray m (dims);
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
342 double *v = m.fortran_vec ();
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
343
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
344 for (octave_idx_type i = 0; i < len; i++)
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
345 v[i] = octave::rand::scalar (a(i));
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
346
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
347 return m;
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
348 }
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
349 }
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
350 else
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
351 return octave::rand::nd_array (dims);
14655
43db83eff9db Implement single precision rand, randn, rande, randg and randp generators (bug #34351, #36293)
David Bateman <dbateman@free.fr>
parents: 14620
diff changeset
352 }
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
353 }
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
354
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14854
diff changeset
355 DEFUN (rand, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
356 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
357 @deftypefn {} {} rand (@var{n})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
358 @deftypefnx {} {} rand (@var{m}, @var{n}, @dots{})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
359 @deftypefnx {} {} rand ([@var{m} @var{n} @dots{}])
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
360 @deftypefnx {} {@var{v} =} rand ("state")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
361 @deftypefnx {} {} rand ("state", @var{v})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
362 @deftypefnx {} {} rand ("state", "reset")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
363 @deftypefnx {} {@var{v} =} rand ("seed")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
364 @deftypefnx {} {} rand ("seed", @var{v})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
365 @deftypefnx {} {} rand ("seed", "reset")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
366 @deftypefnx {} {} rand (@dots{}, "single")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
367 @deftypefnx {} {} rand (@dots{}, "double")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
368 Return a matrix with random elements uniformly distributed on the
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
369 interval (0, 1).
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
370
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
371 The arguments are handled the same as the arguments for @code{eye}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
372
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
373 You can query the state of the random number generator using the form
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
374
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
375 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
376 v = rand ("state")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
377 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
378
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
379 This returns a column vector @var{v} of length 625. Later, you can restore
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
380 the random number generator to the state @var{v} using the form
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
381
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
382 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
383 rand ("state", v)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
384 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
385
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
386 @noindent
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
387 You may also initialize the state vector from an arbitrary vector of length
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
388 @leq{} 625 for @var{v}. This new state will be a hash based on the value of
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
389 @var{v}, not @var{v} itself.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
390
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
391 By default, the generator is initialized from @code{/dev/urandom} if it is
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
392 available, otherwise from CPU time, wall clock time, and the current
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
393 fraction of a second. Note that this differs from @sc{matlab}, which
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
394 always initializes the state to the same state at startup. To obtain
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
395 behavior comparable to @sc{matlab}, initialize with a deterministic state
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
396 vector in Octave's startup files (@pxref{Startup Files}).
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
397
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
398 To compute the pseudo-random sequence, @code{rand} uses the Mersenne
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
399 Twister with a period of @math{2^{19937}-1}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
400 (See @nospell{M. Matsumoto and T. Nishimura},
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
401 @cite{Mersenne Twister: A 623-dimensionally equidistributed uniform
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
402 pseudorandom number generator},
27800
5a6a19a4e3da doc: Use Texinfo non-sentence ending periods in citations.
Rik <rik@octave.org>
parents: 27277
diff changeset
403 @nospell{ACM} Trans.@: on Modeling and Computer Simulation Vol.@: 8, No.@: 1,
5a6a19a4e3da doc: Use Texinfo non-sentence ending periods in citations.
Rik <rik@octave.org>
parents: 27277
diff changeset
404 pp.@: 3--30, January 1998,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
405 @url{http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html}).
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
406 Do @strong{not} use for cryptography without securely hashing several
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
407 returned values together, otherwise the generator state can be learned after
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
408 reading 624 consecutive values.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
409
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
410 Older versions of Octave used a different random number generator.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
411 The new generator is used by default as it is significantly faster than the
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
412 old generator, and produces random numbers with a significantly longer cycle
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
413 time. However, in some circumstances it might be desirable to obtain the
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
414 same random sequences as produced by the old generators. To do this the
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
415 keyword @qcode{"seed"} is used to specify that the old generators should
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
416 be used, as in
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
417
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
418 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
419 rand ("seed", val)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
420 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
421
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
422 @noindent
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
423 which sets the seed of the generator to @var{val}. The seed of the
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
424 generator can be queried with
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
425
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
426 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
427 s = rand ("seed")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
428 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
429
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
430 However, it should be noted that querying the seed will not cause
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
431 @code{rand} to use the old generators, only setting the seed will. To cause
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
432 @code{rand} to once again use the new generators, the keyword
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
433 @qcode{"state"} should be used to reset the state of the @code{rand}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
434
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
435 The state or seed of the generator can be reset to a new random value using
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
436 the @qcode{"reset"} keyword.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
437
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
438 The class of the value returned can be controlled by a trailing
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
439 @qcode{"double"} or @qcode{"single"} argument. These are the only valid
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
440 classes.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
441 @seealso{randn, rande, randg, randp}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
442 @end deftypefn */)
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
443 {
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
444 return do_rand (args, args.length (), "rand", "uniform");
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
445 }
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
446
17787
175b392e91fe Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents: 17744
diff changeset
447 // FIXME: The old generator (selected when "seed" is set) will not
8871
fb1c929dbbb7 tests vs. 64-bit indexing
John W. Eaton <jwe@octave.org>
parents: 8828
diff changeset
448 // work properly if compiled to use 64-bit integers.
fb1c929dbbb7 tests vs. 64-bit indexing
John W. Eaton <jwe@octave.org>
parents: 8828
diff changeset
449
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
450 /*
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
451 %!test # "state" can be a scalar
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
452 %! rand ("state", 12); x = rand (1,4);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
453 %! rand ("state", 12); y = rand (1,4);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
454 %! assert (x, y);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
455 %!test # "state" can be a vector
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
456 %! rand ("state", [12,13]); x = rand (1,4);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
457 %! rand ("state", [12;13]); y = rand (1,4);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
458 %! assert (x, y);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
459 %!test # querying "state" returns a value which can be used later
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
460 %! s = rand ("state"); x = rand (1,2);
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
461 %! rand ("state", s); y = rand (1,2);
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
462 %! assert (x, y);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
463 %!test # querying "state" doesn't disturb sequence
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
464 %! rand ("state", 12); rand (1,2); x = rand (1,2);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
465 %! rand ("state", 12); rand (1,2); s = rand ("state"); y = rand (1,2);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
466 %! assert (x, y);
24816
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
467 %! rand ("state", s); z = rand (1,2);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
468 %! assert (x, z);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
469 %!test # "seed" must be a scalar
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
470 %! rand ("seed", 12); x = rand (1,4);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
471 %! rand ("seed", 12); y = rand (1,4);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
472 %! assert (x, y);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
473 %!error <seed must be a real scalar> rand ("seed", [12,13])
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
474 %!test # querying "seed" returns a value which can be used later
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
475 %! s = rand ("seed"); x = rand (1,2);
24816
261d23b8933b test: ensure all unit tests restore global random state after setting it
Mike Miller <mtmiller@octave.org>
parents: 24106
diff changeset
476 %! rand ("seed", s); y = rand (1,2);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
477 %! assert (x, y);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
478 %!test # querying "seed" doesn't disturb sequence
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
479 %! rand ("seed", 12); rand (1,2); x = rand (1,2);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
480 %! rand ("seed", 12); rand (1,2); s = rand ("seed"); y = rand (1,2);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
481 %! assert (x, y);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
482 %! rand ("seed", s); z = rand (1,2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
483 %! assert (x, z);
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
484 */
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
485
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
486 /*
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
487 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
488 %! ## Test a known fixed state
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
489 %! rand ("state", 1);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
490 %! assert (rand (1,6), [0.1343642441124013 0.8474337369372327 0.763774618976614 0.2550690257394218 0.495435087091941 0.4494910647887382], eps);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
491 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
492 %! ## Test a known fixed seed
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
493 %! rand ("seed", 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
494 %! assert (rand (1,6), [0.8668024251237512 0.9126510815694928 0.09366085007786751 0.1664607301354408 0.7408077004365623 0.7615650338120759], 1e-6);
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
495 %!test
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
496 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
497 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
498 %! rand ("state", 12);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
499 %! x = rand (100_000, 1);
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
500 %! assert (min (x) > 0); #*** Please report this!!! ***
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
501 %! assert (max (x) < 1); #*** Please report this!!! ***
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
502 %! assert (mean (x), 0.5, 0.0024);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
503 %! assert (var (x), 1/48, 0.0632);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
504 %! assert (skewness (x), 0, 0.012);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
505 %! assert (kurtosis (x), -6/5, 0.0094);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
506 %! endif
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
507 %!test
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
508 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
509 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
510 %! rand ("seed", 12);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
511 %! x = rand (100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
512 %! assert (max (x) < 1); #*** Please report this!!! ***
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
513 %! assert (min (x) > 0); #*** Please report this!!! ***
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
514 %! assert (mean (x), 0.5, 0.0024);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
515 %! assert (var (x), 1/48, 0.0632);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
516 %! assert (skewness (x), 0, 0.012);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
517 %! assert (kurtosis (x), -6/5, 0.0094);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
518 %! endif
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
519 */
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
520
17258
213ee68b59da Handle out-of-range values consistently when initializing random number generator.
Philipp Kutin <philipp.kutin@gmail.com>
parents: 15195
diff changeset
521 /*
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
522 ## Test out-of-range values as rand() seeds.
17258
213ee68b59da Handle out-of-range values consistently when initializing random number generator.
Philipp Kutin <philipp.kutin@gmail.com>
parents: 15195
diff changeset
523 %!function v = __rand_sample__ (initval)
213ee68b59da Handle out-of-range values consistently when initializing random number generator.
Philipp Kutin <philipp.kutin@gmail.com>
parents: 15195
diff changeset
524 %! rand ("state", initval);
213ee68b59da Handle out-of-range values consistently when initializing random number generator.
Philipp Kutin <philipp.kutin@gmail.com>
parents: 15195
diff changeset
525 %! v = rand (1, 6);
213ee68b59da Handle out-of-range values consistently when initializing random number generator.
Philipp Kutin <philipp.kutin@gmail.com>
parents: 15195
diff changeset
526 %!endfunction
213ee68b59da Handle out-of-range values consistently when initializing random number generator.
Philipp Kutin <philipp.kutin@gmail.com>
parents: 15195
diff changeset
527 %!
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
528 %!assert (__rand_sample__ (-1), __rand_sample__ (0))
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
529 %!assert (__rand_sample__ (-Inf), __rand_sample__ (0))
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
530 %!assert (__rand_sample__ (2^33), __rand_sample__ (intmax ("uint32")))
25651
c759aa39c23a Produce same random number stream for "state" initialized to Inf (bug #54342).
Rik <rik@octave.org>
parents: 25143
diff changeset
531 %!assert (__rand_sample__ (Inf), __rand_sample__ (0))
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
532 %!assert (__rand_sample__ (NaN), __rand_sample__ (0))
17258
213ee68b59da Handle out-of-range values consistently when initializing random number generator.
Philipp Kutin <philipp.kutin@gmail.com>
parents: 15195
diff changeset
533 */
213ee68b59da Handle out-of-range values consistently when initializing random number generator.
Philipp Kutin <philipp.kutin@gmail.com>
parents: 15195
diff changeset
534
25926
373fe1608f7c Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension (bug #54781).
Rik <rik@octave.org>
parents: 25828
diff changeset
535 /*
373fe1608f7c Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension (bug #54781).
Rik <rik@octave.org>
parents: 25828
diff changeset
536 ## Check that negative dimensions are treated as zero for Matlab compatibility
373fe1608f7c Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension (bug #54781).
Rik <rik@octave.org>
parents: 25828
diff changeset
537 %!assert (size (rand (1, -1, 2)), [1, 0, 2])
373fe1608f7c Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension (bug #54781).
Rik <rik@octave.org>
parents: 25828
diff changeset
538
373fe1608f7c Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension (bug #54781).
Rik <rik@octave.org>
parents: 25828
diff changeset
539 ## Test input validation
373fe1608f7c Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension (bug #54781).
Rik <rik@octave.org>
parents: 25828
diff changeset
540 %!error <conversion of 1.1 to.* failed> rand (1, 1.1)
25927
d6581134daaa Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension in a dimension vector (bug #54781).
Rik <rik@octave.org>
parents: 25926
diff changeset
541 %!error <dimensions must be .* array of integers> rand ([1, 1.1])
25926
373fe1608f7c Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension (bug #54781).
Rik <rik@octave.org>
parents: 25828
diff changeset
542 */
373fe1608f7c Emit an error when utility matrices (zeros, ones, rand, etc.) are given a fractional dimension (bug #54781).
Rik <rik@octave.org>
parents: 25828
diff changeset
543
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
544 static std::string current_distribution = octave::rand::distribution ();
4307
fd034cd46aea [project @ 2003-01-24 19:20:50 by jwe]
jwe
parents: 4153
diff changeset
545
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14854
diff changeset
546 DEFUN (randn, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
547 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
548 @deftypefn {} {} randn (@var{n})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
549 @deftypefnx {} {} randn (@var{m}, @var{n}, @dots{})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
550 @deftypefnx {} {} randn ([@var{m} @var{n} @dots{}])
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
551 @deftypefnx {} {@var{v} =} randn ("state")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
552 @deftypefnx {} {} randn ("state", @var{v})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
553 @deftypefnx {} {} randn ("state", "reset")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
554 @deftypefnx {} {@var{v} =} randn ("seed")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
555 @deftypefnx {} {} randn ("seed", @var{v})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
556 @deftypefnx {} {} randn ("seed", "reset")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
557 @deftypefnx {} {} randn (@dots{}, "single")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
558 @deftypefnx {} {} randn (@dots{}, "double")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
559 Return a matrix with normally distributed random elements having zero mean
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
560 and variance one.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
561
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
562 The arguments are handled the same as the arguments for @code{rand}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
563
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
564 By default, @code{randn} uses the @nospell{Marsaglia and Tsang}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
565 ``Ziggurat technique'' to transform from a uniform to a normal distribution.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
566
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
567 The class of the value returned can be controlled by a trailing
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
568 @qcode{"double"} or @qcode{"single"} argument. These are the only valid
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
569 classes.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
570
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
571 Reference: @nospell{G. Marsaglia and W.W. Tsang},
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
572 @cite{Ziggurat Method for Generating Random Variables},
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
573 J. Statistical Software, vol 5, 2000,
25143
13fd0610480f doc: Use https whenever possible in @url entries.
Rik <rik@octave.org>
parents: 25054
diff changeset
574 @url{https://www.jstatsoft.org/v05/i08/}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
575
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
576 @seealso{rand, rande, randg, randp}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
577 @end deftypefn */)
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
578 {
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
579 return do_rand (args, args.length (), "randn", "normal");
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
580 }
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
581
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
582 /*
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
583 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
584 %! ## Test a known fixed state
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
585 %! randn ("state", 1);
24989
15d2f32db174 test: relax tolerances on randn, randg tests to pass on i386 (bug #53438)
Mike Miller <mtmiller@octave.org>
parents: 24856
diff changeset
586 %! assert (randn (1, 6), [-2.666521678978671 -0.7381719971724564 1.507903992673601 0.6019427189162239 -0.450661261143348 -0.7054431351574116], 14*eps);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
587 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
588 %! ## Test a known fixed seed
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
589 %! randn ("seed", 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
590 %! assert (randn (1, 6), [-1.039402365684509 -1.25938892364502 0.1968704611063004 0.3874166905879974 -0.5976632833480835 -0.6615074276924133], 1e-6);
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
591 %!test
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
592 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
593 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
594 %! randn ("state", 12);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
595 %! x = randn (100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
596 %! assert (mean (x), 0, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
597 %! assert (var (x), 1, 0.02);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
598 %! assert (skewness (x), 0, 0.02);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
599 %! assert (kurtosis (x), 0, 0.04);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
600 %! endif
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
601 %!test
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
602 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
603 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
604 %! randn ("seed", 12);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
605 %! x = randn (100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
606 %! assert (mean (x), 0, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
607 %! assert (var (x), 1, 0.02);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
608 %! assert (skewness (x), 0, 0.02);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
609 %! assert (kurtosis (x), 0, 0.04);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
610 %! endif
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
611 */
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
612
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14854
diff changeset
613 DEFUN (rande, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
614 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
615 @deftypefn {} {} rande (@var{n})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
616 @deftypefnx {} {} rande (@var{m}, @var{n}, @dots{})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
617 @deftypefnx {} {} rande ([@var{m} @var{n} @dots{}])
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
618 @deftypefnx {} {@var{v} =} rande ("state")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
619 @deftypefnx {} {} rande ("state", @var{v})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
620 @deftypefnx {} {} rande ("state", "reset")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
621 @deftypefnx {} {@var{v} =} rande ("seed")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
622 @deftypefnx {} {} rande ("seed", @var{v})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
623 @deftypefnx {} {} rande ("seed", "reset")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
624 @deftypefnx {} {} rande (@dots{}, "single")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
625 @deftypefnx {} {} rande (@dots{}, "double")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
626 Return a matrix with exponentially distributed random elements.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
627
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
628 The arguments are handled the same as the arguments for @code{rand}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
629
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
630 By default, @code{rande} uses the @nospell{Marsaglia and Tsang}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
631 ``Ziggurat technique'' to transform from a uniform to an exponential
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
632 distribution.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
633
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
634 The class of the value returned can be controlled by a trailing
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
635 @qcode{"double"} or @qcode{"single"} argument. These are the only valid
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
636 classes.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
637
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
638 Reference: @nospell{G. Marsaglia and W.W. Tsang},
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
639 @cite{Ziggurat Method for Generating Random Variables},
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
640 J. Statistical Software, vol 5, 2000,
25143
13fd0610480f doc: Use https whenever possible in @url entries.
Rik <rik@octave.org>
parents: 25054
diff changeset
641 @url{https://www.jstatsoft.org/v05/i08/}
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
642
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
643 @seealso{rand, randn, randg, randp}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
644 @end deftypefn */)
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
645 {
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
646 return do_rand (args, args.length (), "rande", "exponential");
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
647 }
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
648
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
649 /*
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
650 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
651 %! ## Test a known fixed state
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
652 %! rande ("state", 1);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
653 %! assert (rande (1, 6), [3.602973885835625 0.1386190677555021 0.6743112889616958 0.4512830847258422 0.7255744741233175 0.3415969205292291], 2*eps);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
654 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
655 %! ## Test a known fixed seed
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
656 %! rande ("seed", 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
657 %! assert (rande (1, 6), [0.06492075175653866 1.717980206012726 0.4816154008731246 0.5231300676241517 0.103910739364359 1.668931916356087], 1e-6);
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
658 %!test
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
659 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
660 %! ## statistical tests may fail occasionally
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
661 %! rande ("state", 1);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
662 %! x = rande (100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
663 %! assert (min (x) > 0); # *** Please report this!!! ***
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
664 %! assert (mean (x), 1, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
665 %! assert (var (x), 1, 0.03);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
666 %! assert (skewness (x), 2, 0.06);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
667 %! assert (kurtosis (x), 6, 0.7);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
668 %! endif
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
669 %!test
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
670 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
671 %! ## statistical tests may fail occasionally
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
672 %! rande ("seed", 1);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
673 %! x = rande (100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
674 %! assert (min (x)>0); # *** Please report this!!! ***
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
675 %! assert (mean (x), 1, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
676 %! assert (var (x), 1, 0.03);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
677 %! assert (skewness (x), 2, 0.06);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
678 %! assert (kurtosis (x), 6, 0.7);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
679 %! endif
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
680 */
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
681
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14854
diff changeset
682 DEFUN (randg, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
683 doc: /* -*- texinfo -*-
24106
a6cf8e06603a doc: Correct documentation for randg (bug #52118).
Rik <rik@octave.org>
parents: 23219
diff changeset
684 @deftypefn {} {} randg (@var{a}, @var{n})
a6cf8e06603a doc: Correct documentation for randg (bug #52118).
Rik <rik@octave.org>
parents: 23219
diff changeset
685 @deftypefnx {} {} randg (@var{a}, @var{m}, @var{n}, @dots{})
a6cf8e06603a doc: Correct documentation for randg (bug #52118).
Rik <rik@octave.org>
parents: 23219
diff changeset
686 @deftypefnx {} {} randg (@var{a}, [@var{m} @var{n} @dots{}])
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
687 @deftypefnx {} {@var{v} =} randg ("state")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
688 @deftypefnx {} {} randg ("state", @var{v})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
689 @deftypefnx {} {} randg ("state", "reset")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
690 @deftypefnx {} {@var{v} =} randg ("seed")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
691 @deftypefnx {} {} randg ("seed", @var{v})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
692 @deftypefnx {} {} randg ("seed", "reset")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
693 @deftypefnx {} {} randg (@dots{}, "single")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
694 @deftypefnx {} {} randg (@dots{}, "double")
24106
a6cf8e06603a doc: Correct documentation for randg (bug #52118).
Rik <rik@octave.org>
parents: 23219
diff changeset
695
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
696 Return a matrix with @code{gamma (@var{a},1)} distributed random elements.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
697
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
698 The arguments are handled the same as the arguments for @code{rand}, except
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
699 for the argument @var{a}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
700
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
701 This can be used to generate many distributions:
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
702
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
703 @table @asis
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
704 @item @code{gamma (a, b)} for @code{a > -1}, @code{b > 0}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
705
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
706 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
707 r = b * randg (a)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
708 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
709
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
710 @item @code{beta (a, b)} for @code{a > -1}, @code{b > -1}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
711
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
712 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
713 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
714 r1 = randg (a, 1)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
715 r = r1 / (r1 + randg (b, 1))
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
716 @end group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
717 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
718
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
719 @item @code{Erlang (a, n)}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
720
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
721 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
722 r = a * randg (n)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
723 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
724
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
725 @item @code{chisq (df)} for @code{df > 0}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
726
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
727 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
728 r = 2 * randg (df / 2)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
729 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
730
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
731 @item @code{t (df)} for @code{0 < df < inf} (use randn if df is infinite)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
732
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
733 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
734 r = randn () / sqrt (2 * randg (df / 2) / df)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
735 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
736
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
737 @item @code{F (n1, n2)} for @code{0 < n1}, @code{0 < n2}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
738
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
739 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
740 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
741 ## r1 equals 1 if n1 is infinite
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
742 r1 = 2 * randg (n1 / 2) / n1
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
743 ## r2 equals 1 if n2 is infinite
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
744 r2 = 2 * randg (n2 / 2) / n2
21968
973db845cb43 doc: Remove stray '\n' from docstrings.
Rik <rik@octave.org>
parents: 21966
diff changeset
745 r = r1 / r2
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
746 @end group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
747 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
748
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
749 @item negative @code{binomial (n, p)} for @code{n > 0}, @code{0 < p <= 1}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
750
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
751 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
752 r = randp ((1 - p) / p * randg (n))
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
753 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
754
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
755 @item non-central @code{chisq (df, L)}, for @code{df >= 0} and @code{L > 0}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
756 (use chisq if @code{L = 0})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
757
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
758 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
759 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
760 r = randp (L / 2)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
761 r(r > 0) = 2 * randg (r(r > 0))
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
762 r(df > 0) += 2 * randg (df(df > 0)/2)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
763 @end group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
764 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
765
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
766 @item @code{Dirichlet (a1, @dots{} ak)}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
767
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
768 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
769 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
770 r = (randg (a1), @dots{}, randg (ak))
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
771 r = r / sum (r)
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
772 @end group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
773 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
774
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
775 @end table
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
776
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
777 The class of the value returned can be controlled by a trailing
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
778 @qcode{"double"} or @qcode{"single"} argument. These are the only valid
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
779 classes.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
780 @seealso{rand, randn, rande, randp}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
781 @end deftypefn */)
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
782 {
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
783 int nargin = args.length ();
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
784
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
785 if (nargin < 1)
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
786 error ("randg: insufficient arguments");
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
787
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
788 return do_rand (args, nargin, "randg", "gamma", true);
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
789 }
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
790
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
791 /*
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
792 %!test
21580
ecce63c99c3f maint: Add semicolons to terminate code in %! blocks.
Rik <rik@octave.org>
parents: 21301
diff changeset
793 %! randg ("state", 12);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
794 %! assert (randg ([-inf, -1, 0, inf, nan]), [nan, nan, nan, nan, nan]); # *** Please report
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
795
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
796 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
797 %! ## Test a known fixed state
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
798 %! randg ("state", 1);
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
799 %! assert (randg (0.1, 1, 6), [0.0103951513331241 8.335671459898252e-05 0.00138691397249762 0.000587308416993855 0.495590518784736 2.3921917414795e-12], eps);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
800 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
801 %! ## Test a known fixed state
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
802 %! randg ("state", 1);
24989
15d2f32db174 test: relax tolerances on randn, randg tests to pass on i386 (bug #53438)
Mike Miller <mtmiller@octave.org>
parents: 24856
diff changeset
803 %! assert (randg (0.95, 1, 6), [3.099382433255327 0.3974529788871218 0.644367450750855 1.143261091802246 1.964111762696822 0.04011915547957939], 12*eps);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
804 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
805 %! ## Test a known fixed state
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
806 %! randg ("state", 1);
24989
15d2f32db174 test: relax tolerances on randn, randg tests to pass on i386 (bug #53438)
Mike Miller <mtmiller@octave.org>
parents: 24856
diff changeset
807 %! assert (randg (1, 1, 6), [0.2273389379645993 1.288822625058359 0.2406335209340746 1.218869553370733 1.024649860162554 0.09631230343599533], 40*eps);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
808 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
809 %! ## Test a known fixed state
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
810 %! randg ("state", 1);
24989
15d2f32db174 test: relax tolerances on randn, randg tests to pass on i386 (bug #53438)
Mike Miller <mtmiller@octave.org>
parents: 24856
diff changeset
811 %! assert (randg (10, 1, 6), [3.520369644331133 15.15369864472106 8.332112081991205 8.406211067432674 11.81193475187611 10.88792728177059], 56*eps);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
812 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
813 %! ## Test a known fixed state
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
814 %! randg ("state", 1);
24989
15d2f32db174 test: relax tolerances on randn, randg tests to pass on i386 (bug #53438)
Mike Miller <mtmiller@octave.org>
parents: 24856
diff changeset
815 %! assert (randg (100, 1, 6), [75.34570255262264 115.4911985594699 95.23493031356388 95.48926019250911 106.2397448229803 103.4813150404118], 256*eps);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
816 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
817 %! ## Test a known fixed seed
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
818 %! randg ("seed", 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
819 %! assert (randg (0.1, 1, 6), [0.07144210487604141 0.460641473531723 0.4749028384685516 0.06823389977216721 0.000293838675133884 1.802567535340305e-12], 1e-6);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
820 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
821 %! ## Test a known fixed seed
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
822 %! randg ("seed", 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
823 %! assert (randg (0.95, 1, 6), [1.664905071258545 1.879976987838745 1.905677795410156 0.9948706030845642 0.5606933236122131 0.0766092911362648], 1e-6);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
824 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
825 %! ## Test a known fixed seed
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
826 %! randg ("seed", 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
827 %! assert (randg (1, 1, 6), [0.03512085229158401 0.6488978862762451 0.8114678859710693 0.1666885763406754 1.60791552066803 1.90356981754303], 1e-6);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
828 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
829 %! ## Test a known fixed seed
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
830 %! randg ("seed", 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
831 %! assert (randg (10, 1, 6), [6.566435813903809 10.11648464202881 10.73162078857422 7.747178077697754 6.278522491455078 6.240195751190186], 1e-5);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
832 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
833 %! ## Test a known fixed seed
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
834 %! randg ("seed", 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
835 %! assert (randg (100, 1, 6), [89.40208435058594 101.4734725952148 103.4020004272461 93.62763214111328 88.33104705810547 88.1871337890625], 1e-4);
18573
53ba52143af7 Fix dead assignment in oct-rand.cc do_float_scalar (bug #41827).
Branden Archer <b.m.archer4@gmail.com>
parents: 18436
diff changeset
836 %!test
53ba52143af7 Fix dead assignment in oct-rand.cc do_float_scalar (bug #41827).
Branden Archer <b.m.archer4@gmail.com>
parents: 18436
diff changeset
837 %! ## Test out-of-bounds values produce NaN w/old-style generators & floats
53ba52143af7 Fix dead assignment in oct-rand.cc do_float_scalar (bug #41827).
Branden Archer <b.m.archer4@gmail.com>
parents: 18436
diff changeset
838 %! randg ("seed", 1);
53ba52143af7 Fix dead assignment in oct-rand.cc do_float_scalar (bug #41827).
Branden Archer <b.m.archer4@gmail.com>
parents: 18436
diff changeset
839 %! result = randg ([-2 Inf], "single");
18574
756e906bdfda Fix %!test comparing NaN (single) to NaN (double) in cset 53ba52143af7.
Rik <rik@octave.org>
parents: 18573
diff changeset
840 %! assert (result, single ([NaN NaN]));
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
841
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
842 %!test
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
843 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
844 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
845 %! randg ("state", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
846 %! a = 0.1;
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
847 %! x = randg (a, 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
848 %! assert (mean (x), a, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
849 %! assert (var (x), a, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
850 %! assert (skewness (x), 2/sqrt (a), 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
851 %! assert (kurtosis (x), 6/a, 50);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
852 %! endif
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
853 %!test
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
854 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
855 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
856 %! randg ("state", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
857 %! a = 0.95;
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
858 %! x = randg (a, 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
859 %! assert (mean (x), a, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
860 %! assert (var (x), a, 0.04);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
861 %! assert (skewness (x), 2/sqrt (a), 0.2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
862 %! assert (kurtosis (x), 6/a, 2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
863 %! endif
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
864 %!test
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
865 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
866 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
867 %! randg ("state", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
868 %! a = 1;
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
869 %! x = randg (a, 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
870 %! assert (mean (x), a, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
871 %! assert (var (x), a, 0.04);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
872 %! assert (skewness (x), 2/sqrt (a), 0.2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
873 %! assert (kurtosis (x), 6/a, 2);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
874 %! endif
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
875 %!test
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
876 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
877 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
878 %! randg ("state", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
879 %! a = 10;
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
880 %! x = randg (a, 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
881 %! assert (mean (x), a, 0.1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
882 %! assert (var (x), a, 0.5);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
883 %! assert (skewness (x), 2/sqrt (a), 0.1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
884 %! assert (kurtosis (x), 6/a, 0.5);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
885 %! endif
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
886 %!test
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
887 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
888 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
889 %! randg ("state", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
890 %! a = 100;
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
891 %! x = randg (a, 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
892 %! assert (mean (x), a, 0.2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
893 %! assert (var (x), a, 2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
894 %! assert (skewness (x), 2/sqrt (a), 0.05);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
895 %! assert (kurtosis (x), 6/a, 0.2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
896 %! endif
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
897 %!test
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
898 %! randg ("seed", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
899 %!assert (randg ([-inf, -1, 0, inf, nan]), [nan, nan, nan, nan, nan]) # *** Please report
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
900 %!test
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
901 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
902 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
903 %! randg ("seed", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
904 %! a = 0.1;
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
905 %! x = randg (a, 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
906 %! assert (mean (x), a, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
907 %! assert (var (x), a, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
908 %! assert (skewness (x), 2/sqrt (a), 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
909 %! assert (kurtosis (x), 6/a, 50);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
910 %! endif
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
911 %!test
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
912 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
913 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
914 %! randg ("seed", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
915 %! a = 0.95;
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
916 %! x = randg (a, 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
917 %! assert (mean (x), a, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
918 %! assert (var (x), a, 0.04);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
919 %! assert (skewness (x), 2/sqrt (a), 0.2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
920 %! assert (kurtosis (x), 6/a, 2);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
921 %! endif
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
922 %!test
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
923 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
924 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
925 %! randg ("seed", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
926 %! a = 1;
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
927 %! x = randg (a, 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
928 %! assert (mean (x), a, 0.01);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
929 %! assert (var (x), a, 0.04);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
930 %! assert (skewness (x), 2/sqrt (a), 0.2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
931 %! assert (kurtosis (x), 6/a, 2);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
932 %! endif
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
933 %!test
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
934 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
935 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
936 %! randg ("seed", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
937 %! a = 10;
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
938 %! x = randg (a, 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
939 %! assert (mean (x), a, 0.1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
940 %! assert (var (x), a, 0.5);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
941 %! assert (skewness (x), 2/sqrt (a), 0.1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
942 %! assert (kurtosis (x), 6/a, 0.5);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
943 %! endif
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
944 %!test
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
945 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
946 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
947 %! randg ("seed", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
948 %! a = 100;
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
949 %! x = randg (a, 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
950 %! assert (mean (x), a, 0.2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
951 %! assert (var (x), a, 2);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
952 %! assert (skewness (x), 2/sqrt (a), 0.05);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
953 %! assert (kurtosis (x), 6/a, 0.2);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
954 %! endif
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
955 */
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
956
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14854
diff changeset
957 DEFUN (randp, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
958 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
959 @deftypefn {} {} randp (@var{l}, @var{n})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
960 @deftypefnx {} {} randp (@var{l}, @var{m}, @var{n}, @dots{})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
961 @deftypefnx {} {} randp (@var{l}, [@var{m} @var{n} @dots{}])
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
962 @deftypefnx {} {@var{v} =} randp ("state")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
963 @deftypefnx {} {} randp ("state", @var{v})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
964 @deftypefnx {} {} randp ("state", "reset")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
965 @deftypefnx {} {@var{v} =} randp ("seed")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
966 @deftypefnx {} {} randp ("seed", @var{v})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
967 @deftypefnx {} {} randp ("seed", "reset")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
968 @deftypefnx {} {} randp (@dots{}, "single")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
969 @deftypefnx {} {} randp (@dots{}, "double")
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
970 Return a matrix with Poisson distributed random elements with mean value
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
971 parameter given by the first argument, @var{l}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
972
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
973 The arguments are handled the same as the arguments for @code{rand}, except
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
974 for the argument @var{l}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
975
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
976 Five different algorithms are used depending on the range of @var{l} and
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
977 whether or not @var{l} is a scalar or a matrix.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
978
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
979 @table @asis
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
980 @item For scalar @var{l} @leq{} 12, use direct method.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
981 W.H. Press, et al., @cite{Numerical Recipes in C},
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
982 Cambridge University Press, 1992.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
983
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
984 @item For scalar @var{l} > 12, use rejection method.[1]
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
985 W.H. Press, et al., @cite{Numerical Recipes in C},
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
986 Cambridge University Press, 1992.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
987
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
988 @item For matrix @var{l} @leq{} 10, use inversion method.[2]
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
989 @nospell{E. Stadlober, et al., WinRand source code}, available via FTP.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
990
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
991 @item For matrix @var{l} > 10, use patchwork rejection method.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
992 @nospell{E. Stadlober, et al., WinRand source code}, available via FTP, or
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
993 @nospell{H. Zechner}, @cite{Efficient sampling from continuous and discrete
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
994 unimodal distributions}, Doctoral Dissertation, 156pp., Technical
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
995 University @nospell{Graz}, Austria, 1994.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
996
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
997 @item For @var{l} > 1e8, use normal approximation.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
998 @nospell{L. Montanet}, et al., @cite{Review of Particle Properties},
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
999 Physical Review D 50 p1284, 1994.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1000 @end table
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1001
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1002 The class of the value returned can be controlled by a trailing
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1003 @qcode{"double"} or @qcode{"single"} argument. These are the only valid
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1004 classes.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1005 @seealso{rand, randn, rande, randg}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1006 @end deftypefn */)
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1007 {
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1008 int nargin = args.length ();
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1009
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1010 if (nargin < 1)
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1011 error ("randp: insufficient arguments");
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1012
20894
e528d7ab1cad rand.cc: Overhaul file to make use of new C++ archetype.
Rik <rik@octave.org>
parents: 20853
diff changeset
1013 return do_rand (args, nargin, "randp", "poisson", true);
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1014 }
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1015
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1016 /*
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1017 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1018 %! randp ("state", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1019 %! assert (randp ([-inf, -1, 0, inf, nan]), [nan, nan, 0, nan, nan]); # *** Please report
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1020 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
1021 %! ## Test a known fixed state
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1022 %! randp ("state", 1);
21580
ecce63c99c3f maint: Add semicolons to terminate code in %! blocks.
Rik <rik@octave.org>
parents: 21301
diff changeset
1023 %! assert (randp (5, 1, 6), [5 5 3 7 7 3]);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1024 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
1025 %! ## Test a known fixed state
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1026 %! randp ("state", 1);
21580
ecce63c99c3f maint: Add semicolons to terminate code in %! blocks.
Rik <rik@octave.org>
parents: 21301
diff changeset
1027 %! assert (randp (15, 1, 6), [13 15 8 18 18 15]);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1028 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
1029 %! ## Test a known fixed state
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1030 %! randp ("state", 1);
21580
ecce63c99c3f maint: Add semicolons to terminate code in %! blocks.
Rik <rik@octave.org>
parents: 21301
diff changeset
1031 %! assert (randp (1e9, 1, 6), [999915677 999976657 1000047684 1000019035 999985749 999977692], -1e-6);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1032 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
1033 %! ## Test a known fixed seed
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1034 %! randp ("seed", 1);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1035 %! %%assert (randp (5, 1, 6), [8 2 3 6 6 8])
21580
ecce63c99c3f maint: Add semicolons to terminate code in %! blocks.
Rik <rik@octave.org>
parents: 21301
diff changeset
1036 %! assert (randp (5, 1, 5), [8 2 3 6 6]);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1037 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
1038 %! ## Test a known fixed seed
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1039 %! randp ("seed", 1);
21580
ecce63c99c3f maint: Add semicolons to terminate code in %! blocks.
Rik <rik@octave.org>
parents: 21301
diff changeset
1040 %! assert (randp (15, 1, 6), [15 16 12 10 10 12]);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1041 %!test
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
1042 %! ## Test a known fixed seed
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1043 %! randp ("seed", 1);
21580
ecce63c99c3f maint: Add semicolons to terminate code in %! blocks.
Rik <rik@octave.org>
parents: 21301
diff changeset
1044 %! assert (randp (1e9, 1, 6), [1000006208 1000012224 999981120 999963520 999963072 999981440], -1e-6);
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1045 %!test
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1046 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
1047 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1048 %! randp ("state", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1049 %! for a = [5, 15, 1e9; 0.03, 0.03, -5e-3; 0.03, 0.03, 0.03]
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
1050 %! x = randp (a (1), 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1051 %! assert (min (x) >= 0); # *** Please report this!!! ***
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1052 %! assert (mean (x), a(1), a(2));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1053 %! assert (var (x), a(1), 0.02*a(1));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1054 %! assert (skewness (x), 1/sqrt (a(1)), a(3));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1055 %! assert (kurtosis (x), 1/a(1), 3*a(3));
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1056 %! endfor
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1057 %! endif
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1058 %!test
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1059 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
1060 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1061 %! randp ("state", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1062 %! for a = [5, 15, 1e9; 0.03, 0.03, -5e-3; 0.03, 0.03, 0.03]
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
1063 %! x = randp (a(1)*ones (100_000, 1), 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1064 %! assert (min (x) >= 0); # *** Please report this!!! ***
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1065 %! assert (mean (x), a(1), a(2));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1066 %! assert (var (x), a(1), 0.02*a(1));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1067 %! assert (skewness (x), 1/sqrt (a(1)), a(3));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1068 %! assert (kurtosis (x), 1/a(1), 3*a(3));
6437
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1069 %! endfor
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1070 %! endif
190dfe8b8f08 [project @ 2007-03-23 14:17:31 by dbateman]
dbateman
parents: 6198
diff changeset
1071 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1072 %! randp ("seed", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1073 %! assert (randp ([-inf, -1, 0, inf, nan]), [nan, nan, 0, nan, nan]); # *** Please report
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1074 %!test
6449
a5de12c0f968 [project @ 2007-03-24 11:11:36 by dbateman]
dbateman
parents: 6443
diff changeset
1075 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
1076 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1077 %! randp ("seed", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1078 %! for a = [5, 15, 1e9; 0.03, 0.03, -5e-3; 0.03, 0.03, 0.03]
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
1079 %! x = randp (a(1), 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1080 %! assert (min (x) >= 0); # *** Please report this!!! ***
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1081 %! assert (mean (x), a(1), a(2));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1082 %! assert (var (x), a(1), 0.02*a(1));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1083 %! assert (skewness (x), 1/sqrt (a(1)), a(3));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1084 %! assert (kurtosis (x), 1/a(1), 3*a(3));
6449
a5de12c0f968 [project @ 2007-03-24 11:11:36 by dbateman]
dbateman
parents: 6443
diff changeset
1085 %! endfor
a5de12c0f968 [project @ 2007-03-24 11:11:36 by dbateman]
dbateman
parents: 6443
diff changeset
1086 %! endif
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1087 %!test
6449
a5de12c0f968 [project @ 2007-03-24 11:11:36 by dbateman]
dbateman
parents: 6443
diff changeset
1088 %! if (__random_statistical_tests__)
17336
b81b9d079515 Use '##' for comments which stand alone on a line.
Rik <rik@octave.org>
parents: 17281
diff changeset
1089 %! ## statistical tests may fail occasionally.
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1090 %! randp ("seed", 12);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1091 %! for a = [5, 15, 1e9; 0.03, 0.03, -5e-3; 0.03, 0.03, 0.03]
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
1092 %! x = randp (a(1)*ones (100_000, 1), 100_000, 1);
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1093 %! assert (min (x) >= 0); # *** Please report this!!! ***
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1094 %! assert (mean (x), a(1), a(2));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1095 %! assert (var (x), a(1), 0.02*a(1));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1096 %! assert (skewness (x), 1/sqrt (a(1)), a(3));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14138
diff changeset
1097 %! assert (kurtosis (x), 1/a(1), 3*a(3));
6449
a5de12c0f968 [project @ 2007-03-24 11:11:36 by dbateman]
dbateman
parents: 6443
diff changeset
1098 %! endfor
a5de12c0f968 [project @ 2007-03-24 11:11:36 by dbateman]
dbateman
parents: 6443
diff changeset
1099 %! endif
5730
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1100 */
109fdf7b3dcb [project @ 2006-04-03 19:18:26 by jwe]
jwe
parents: 5355
diff changeset
1101
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14854
diff changeset
1102 DEFUN (randperm, args, ,
21966
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1103 doc: /* -*- texinfo -*-
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1104 @deftypefn {} {} randperm (@var{n})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1105 @deftypefnx {} {} randperm (@var{n}, @var{m})
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1106 Return a row vector containing a random permutation of @code{1:@var{n}}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1107
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1108 If @var{m} is supplied, return @var{m} unique entries, sampled without
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1109 replacement from @code{1:@var{n}}.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1110
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1111 The complexity is O(@var{n}) in memory and O(@var{m}) in time, unless
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1112 @var{m} < @var{n}/5, in which case O(@var{m}) memory is used as well. The
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1113 randomization is performed using rand(). All permutations are equally
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1114 likely.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1115 @seealso{perms}
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21942
diff changeset
1116 @end deftypefn */)
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1117 {
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1118 int nargin = args.length ();
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1119
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1120 if (nargin < 1 || nargin > 2)
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1121 print_usage ();
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1122
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1123 octave_idx_type n = args(0).idx_type_value (true);
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1124 octave_idx_type m = (nargin == 2) ? args(1).idx_type_value (true) : n;
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11553
diff changeset
1125
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1126 if (m < 0 || n < 0)
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1127 error ("randperm: M and N must be non-negative");
13186
2896c083576a Implement second randperm argument for compatibility with Matlab
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 13026
diff changeset
1128
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1129 if (m > n)
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1130 error ("randperm: M must be less than or equal to N");
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1131
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1132 // Quick and dirty heuristic to decide if we allocate or not the
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1133 // whole vector for tracking the truncated shuffle.
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1134 bool short_shuffle = m < n/5;
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1135
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1136 // Generate random numbers.
25433
49e0447413ad use templates and move rand functions inside octave namespace
John W. Eaton <jwe@octave.org>
parents: 25143
diff changeset
1137 NDArray r = octave::rand::nd_array (dim_vector (1, m));
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1138 double *rvec = r.fortran_vec ();
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1139
23450
855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents: 23220
diff changeset
1140 octave_idx_type idx_len = (short_shuffle ? m : n);
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1141 Array<octave_idx_type> idx;
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1142 try
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1143 {
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1144 idx = Array<octave_idx_type> (dim_vector (1, idx_len));
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1145 }
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1146 catch (const std::bad_alloc&)
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1147 {
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1148 // Looks like n is too big and short_shuffle is false.
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1149 // Let's try again, but this time with the alternative.
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1150 idx_len = m;
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1151 short_shuffle = true;
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1152 idx = Array<octave_idx_type> (dim_vector (1, idx_len));
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1153 }
13186
2896c083576a Implement second randperm argument for compatibility with Matlab
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 13026
diff changeset
1154
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1155 octave_idx_type *ivec = idx.fortran_vec ();
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1156
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1157 for (octave_idx_type i = 0; i < idx_len; i++)
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1158 ivec[i] = i;
13255
dd3c5325039c Use a hash map to store permutations in randperm's truncated Knuth shuffle
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 13186
diff changeset
1159
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1160 if (short_shuffle)
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1161 {
22150
c4901d7a2d7d Remove check for std::tr1::unordered_map because we depend on C++11.
Carnë Draug <carandraug@octave.org>
parents: 21968
diff changeset
1162 std::unordered_map<octave_idx_type, octave_idx_type> map (m);
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1163
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1164 // Perform the Knuth shuffle only keeping track of moved
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1165 // entries in the map
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1166 for (octave_idx_type i = 0; i < m; i++)
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1167 {
22407
34ce5be04942 maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents: 22327
diff changeset
1168 octave_idx_type k = i + std::floor (rvec[i] * (n - i));
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1169
22407
34ce5be04942 maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents: 22327
diff changeset
1170 // For shuffling first m entries, no need to use extra storage
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1171 if (k < m)
17662
0b7f5c56f853 Allow randperm to work with bigger inputs (bug #39378)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 17336
diff changeset
1172 {
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1173 std::swap (ivec[i], ivec[k]);
13255
dd3c5325039c Use a hash map to store permutations in randperm's truncated Knuth shuffle
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 13186
diff changeset
1174 }
dd3c5325039c Use a hash map to store permutations in randperm's truncated Knuth shuffle
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 13186
diff changeset
1175 else
dd3c5325039c Use a hash map to store permutations in randperm's truncated Knuth shuffle
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 13186
diff changeset
1176 {
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1177 if (map.find (k) == map.end ())
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1178 map[k] = k;
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1179
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1180 std::swap (ivec[i], map[k]);
13255
dd3c5325039c Use a hash map to store permutations in randperm's truncated Knuth shuffle
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 13186
diff changeset
1181 }
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1182 }
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1183 }
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1184 else
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1185 {
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1186 // Perform the Knuth shuffle of the first m entries
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1187 for (octave_idx_type i = 0; i < m; i++)
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1188 {
22407
34ce5be04942 maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents: 22327
diff changeset
1189 octave_idx_type k = i + std::floor (rvec[i] * (n - i));
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1190 std::swap (ivec[i], ivec[k]);
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1191 }
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1192 }
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1193
20801
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1194 // Convert to doubles, reusing r.
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1195 for (octave_idx_type i = 0; i < m; i++)
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1196 rvec[i] = ivec[i] + 1;
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1197
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1198 if (m < n)
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1199 idx.resize (dim_vector (1, m));
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1200
a542a9bf177e eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20785
diff changeset
1201 // Now create an array object with a cached idx_vector.
21127
df7891224709 maint: Use "return ovl (...)" in DEFUN macros.
Rik <rik@octave.org>
parents: 21100
diff changeset
1202 return ovl (new octave_matrix (r, idx_vector (idx)));
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1203 }
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1204
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1205 /*
14688
42edbe6f6a8d Fix bad two-arg call of randperm (bug #36535)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
1206 %!assert (sort (randperm (20)), 1:20)
42edbe6f6a8d Fix bad two-arg call of randperm (bug #36535)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
1207 %!assert (length (randperm (20,10)), 10)
42edbe6f6a8d Fix bad two-arg call of randperm (bug #36535)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
1208
22489
93ea313301f9 test: Add bug ids (<#####>) to BIST tests.
Rik <rik@octave.org>
parents: 22407
diff changeset
1209 ## Test biggish N
24856
8bb0251fcfde Use a uint32 state vector for random number generators (bug #50256).
Rik <rik@octave.org>
parents: 24817
diff changeset
1210 %!assert <*39378> (length (randperm (30_000^2, 100_000)), 100_000)
17662
0b7f5c56f853 Allow randperm to work with bigger inputs (bug #39378)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 17336
diff changeset
1211
14688
42edbe6f6a8d Fix bad two-arg call of randperm (bug #36535)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
1212 %!test
42edbe6f6a8d Fix bad two-arg call of randperm (bug #36535)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
1213 %! rand ("seed", 0);
42edbe6f6a8d Fix bad two-arg call of randperm (bug #36535)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
1214 %! for i = 1:100
42edbe6f6a8d Fix bad two-arg call of randperm (bug #36535)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
1215 %! p = randperm (305, 30);
42edbe6f6a8d Fix bad two-arg call of randperm (bug #36535)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
1216 %! assert (length (unique (p)), 30);
42edbe6f6a8d Fix bad two-arg call of randperm (bug #36535)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents: 14138
diff changeset
1217 %! endfor
9647
54f45f883a53 optimize & extend randperm
Jaroslav Hajek <highegg@gmail.com>
parents: 9377
diff changeset
1218 */