octave-nkf: src/data.cc annotate

annotate src/data.cc @ 8734:767ed8cc6634

rename internal issorted and issorted_rows functions to is_sorted and is_sorted_rows

author	John W. Eaton <jwe@octave.org>
date	Thu, 12 Feb 2009 15:29:12 -0500
parents	3ef774603887
children	d0755c9db5ed

rev	line source
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1 /*
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2
7017 a1dbe9d80eee [project @ 2007-10-12 21:27:11 by jwe] jwe parents: 7016 diff changeset	3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
a1dbe9d80eee [project @ 2007-10-12 21:27:11 by jwe] jwe parents: 7016 diff changeset	4 2003, 2004, 2005, 2006, 2007 John W. Eaton
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5 Copyright (C) 2009 Jaroslav Hajek
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	6
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	7 This file is part of Octave.
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	8
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	9 Octave is free software; you can redistribute it and/or modify it
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	10 under the terms of the GNU General Public License as published by the
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	11 Free Software Foundation; either version 3 of the License, or (at your
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	12 option) any later version.
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	13
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	14 Octave is distributed in the hope that it will be useful, but WITHOUT
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	17 for more details.
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	18
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	19 You should have received a copy of the GNU General Public License
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	20 along with Octave; see the file COPYING. If not, see
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	21 <http://www.gnu.org/licenses/>.
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	22
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	23 */
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	24
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	25 #ifdef HAVE_CONFIG_H
1192 b6360f2d4fa6 [project @ 1995-03-30 21:38:35 by jwe] jwe parents: 1129 diff changeset	26 #include <config.h>
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	27 #endif
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	28
7078 405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	29 #include "systime.h"
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	30
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	31 #ifdef HAVE_SYS_TYPES_H
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	32 #include <sys/types.h>
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	33 #endif
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	34
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	35 #ifdef HAVE_SYS_RESOURCE_H
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	36 #include <sys/resource.h>
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	37 #endif
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	38
2184 dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	39 #include <cfloat>
dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	40
1728 42b4f904f1af [project @ 1996-01-09 11:36:01 by jwe] jwe parents: 1572 diff changeset	41 #include <string>
42b4f904f1af [project @ 1996-01-09 11:36:01 by jwe] jwe parents: 1572 diff changeset	42
2184 dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	43 #include "lo-ieee.h"
7231 2eb392d058bb [project @ 2007-11-30 18:53:29 by jwe] jwe parents: 7189 diff changeset	44 #include "lo-math.h"
1755 3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe] jwe parents: 1742 diff changeset	45 #include "str-vec.h"
4153 6b96ce9f5743 [project @ 2002-11-06 20:38:49 by jwe] jwe parents: 4114 diff changeset	46 #include "quit.h"
1755 3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe] jwe parents: 1742 diff changeset	47
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	48 #include "Cell.h"
1352 19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	49 #include "defun.h"
19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	50 #include "error.h"
19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	51 #include "gripes.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	52 #include "oct-map.h"
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	53 #include "oct-obj.h"
2366 c90105b99479 [project @ 1996-10-11 23:22:27 by jwe] jwe parents: 2305 diff changeset	54 #include "ov.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	55 #include "ov-float.h"
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	56 #include "ov-complex.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	57 #include "ov-flt-complex.h"
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	58 #include "ov-cx-mat.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	59 #include "ov-flt-cx-mat.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	60 #include "ov-cx-sparse.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	61 #include "parse.h"
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	62 #include "pt-mat.h"
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	63 #include "utils.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	64 #include "variables.h"
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	65 #include "pager.h"
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	66 #include "xnorm.h"
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	67
7914 e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	68 #if ! defined (HAVE_HYPOTF) && defined (HAVE__HYPOTF)
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	69 #define hypotf _hypotf
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	70 #define HAVE_HYPOTF 1
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	71 #endif
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	72
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	73 #define ANY_ALL(FCN) \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	74 \
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	75 octave_value retval; \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	76 \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	77 int nargin = args.length (); \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	78 \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	79 if (nargin == 1 \|\| nargin == 2) \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	80 { \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	81 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	82 \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	83 if (! error_state) \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	84 { \
4556 773a21e4fce8 [project @ 2003-10-28 05:02:10 by jwe] jwe parents: 4554 diff changeset	85 if (dim >= -1) \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	86 retval = args(0).FCN (dim); \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	87 else \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	88 error (#FCN ": invalid dimension argument = %d", dim + 1); \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	89 } \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	90 else \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	91 error (#FCN ": expecting dimension argument to be an integer"); \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	92 } \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	93 else \
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	94 print_usage (); \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	95 \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	96 return retval
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	97
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	98 DEFUN (all, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	99 "-- texinfo --\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	100 @deftypefn {Built-in Function} {} all (@var{x}, @var{dim})\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	101 The function @code{all} behaves like the function @code{any}, except\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	102 that it returns true only if all the elements of a vector, or all the\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	103 elements along dimension @var{dim} of a matrix, are nonzero.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	104 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	105 {
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	106 ANY_ALL (all);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	107 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	108
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	109 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	110
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	111 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	112 %! x = ones (3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	113 %! x(1,1) = 0;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	114 %! assert((all (all (rand (3) + 1) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	115 %! && all (all (x) == [0, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	116 %! && all (x, 1) == [0, 1, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	117 %! && all (x, 2) == [0; 1; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	118
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	119 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	120 %! x = ones (3, 'single');
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	121 %! x(1,1) = 0;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	122 %! assert((all (all (single (rand (3) + 1)) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	123 %! && all (all (x) == [0, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	124 %! && all (x, 1) == [0, 1, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	125 %! && all (x, 2) == [0; 1; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	126
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	127 %!error <Invalid call to all.*> all ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	128 %!error <Invalid call to all.*> all (1, 2, 3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	129
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	130 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	131
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	132 DEFUN (any, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	133 "-- texinfo --\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	134 @deftypefn {Built-in Function} {} any (@var{x}, @var{dim})\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	135 For a vector argument, return 1 if any element of the vector is\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	136 nonzero.\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	137 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	138 For a matrix argument, return a row vector of ones and\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	139 zeros with each element indicating whether any of the elements of the\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	140 corresponding column of the matrix are nonzero. For example,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	141 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	142 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	143 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	144 any (eye (2, 4))\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	145 @result{} [ 1, 1, 0, 0 ]\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	146 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	147 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	148 \n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	149 If the optional argument @var{dim} is supplied, work along dimension\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	150 @var{dim}. For example,\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	151 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	152 @example\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	153 @group\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	154 any (eye (2, 4), 2)\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	155 @result{} [ 1; 1 ]\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	156 @end group\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	157 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	158 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	159 {
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	160 ANY_ALL (any);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	161 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	162
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	163 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	164
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	165 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	166 %! x = zeros (3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	167 %! x(3,3) = 1;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	168 %! assert((all (any (x) == [0, 0, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	169 %! && all (any (ones (3)) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	170 %! && any (x, 1) == [0, 0, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	171 %! && any (x, 2) == [0; 0; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	172
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	173 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	174 %! x = zeros (3,'single');
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	175 %! x(3,3) = 1;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	176 %! assert((all (any (x) == [0, 0, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	177 %! && all (any (ones (3, 'single')) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	178 %! && any (x, 1) == [0, 0, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	179 %! && any (x, 2) == [0; 0; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	180
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	181 %!error <Invalid call to any.*> any ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	182 %!error <Invalid call to any.*> any (1, 2, 3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	183
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	184 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	185
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	186 // These mapping functions may also be useful in other places, eh?
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	187
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	188 typedef double (*d_dd_fcn) (double, double);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	189 typedef float (*f_ff_fcn) (float, float);
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	190
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	191 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	192 map_d_m (d_dd_fcn f, double x, const NDArray& y)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	193 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	194 NDArray retval (y.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	195 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	196
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	197 const double *y_data = y.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	198
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	199 octave_idx_type nel = y.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	200
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	201 for (octave_idx_type i = 0; i < nel; i++)
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	202 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	203 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	204 r_data[i] = f (x, y_data[i]);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	205 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	206
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	207 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	208 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	209
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	210 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	211 map_f_fm (f_ff_fcn f, float x, const FloatNDArray& y)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	212 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	213 FloatNDArray retval (y.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	214 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	215
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	216 const float *y_data = y.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	217
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	218 octave_idx_type nel = y.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	219
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	220 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	221 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	222 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	223 r_data[i] = f (x, y_data[i]);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	224 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	225
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	226 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	227 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	228
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	229 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	230 map_m_d (d_dd_fcn f, const NDArray& x, double y)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	231 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	232 NDArray retval (x.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	233 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	234
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	235 const double *x_data = x.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	236
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	237 octave_idx_type nel = x.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	238
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	239 for (octave_idx_type i = 0; i < nel; i++)
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	240 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	241 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	242 r_data[i] = f (x_data[i], y);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	243 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	244
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	245 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	246 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	247
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	248 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	249 map_fm_f (f_ff_fcn f, const FloatNDArray& x, float y)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	250 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	251 FloatNDArray retval (x.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	252 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	253
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	254 const float *x_data = x.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	255
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	256 octave_idx_type nel = x.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	257
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	258 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	259 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	260 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	261 r_data[i] = f (x_data[i], y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	262 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	263
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	264 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	265 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	266
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	267 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	268 map_m_m (d_dd_fcn f, const NDArray& x, const NDArray& y)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	269 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	270 assert (x.dims () == y.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	271
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	272 NDArray retval (x.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	273 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	274
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	275 const double *x_data = x.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	276 const double *y_data = y.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	277
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	278 octave_idx_type nel = x.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	279
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	280 for (octave_idx_type i = 0; i < nel; i++)
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	281 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	282 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	283 r_data[i] = f (x_data[i], y_data[i]);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	284 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	285
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	286 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	287 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	288
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	289 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	290 map_fm_fm (f_ff_fcn f, const FloatNDArray& x, const FloatNDArray& y)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	291 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	292 assert (x.dims () == y.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	293
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	294 FloatNDArray retval (x.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	295 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	296
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	297 const float *x_data = x.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	298 const float *y_data = y.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	299
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	300 octave_idx_type nel = x.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	301
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	302 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	303 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	304 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	305 r_data[i] = f (x_data[i], y_data[i]);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	306 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	307
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	308 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	309 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	310
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	311 static SparseMatrix
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	312 map_d_s (d_dd_fcn f, double x, const SparseMatrix& y)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	313 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	314 octave_idx_type nr = y.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	315 octave_idx_type nc = y.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	316 SparseMatrix retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	317 double f_zero = f (x, 0.);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	318
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	319 if (f_zero != 0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	320 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	321 retval = SparseMatrix (nr, nc, f_zero);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	322
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	323 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	324 for (octave_idx_type i = y.cidx (j); i < y.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	325 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	326 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	327 retval.data (y.ridx(i) + j * nr) = f (x, y.data (i));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	328 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	329
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	330 retval.maybe_compress (true);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	331 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	332 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	333 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	334 octave_idx_type nz = y.nnz ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	335 retval = SparseMatrix (nr, nc, nz);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	336 octave_idx_type ii = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	337 retval.cidx (ii) = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	338
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	339 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	340 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	341 for (octave_idx_type i = y.cidx (j); i < y.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	342 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	343 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	344 double val = f (x, y.data (i));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	345
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	346 if (val != 0.0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	347 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	348 retval.data (ii) = val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	349 retval.ridx (ii++) = y.ridx (i);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	350 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	351 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	352 retval.cidx (j + 1) = ii;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	353 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	354
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	355 retval.maybe_compress (false);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	356 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	357
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	358 return retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	359 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	360
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	361 static SparseMatrix
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	362 map_s_d (d_dd_fcn f, const SparseMatrix& x, double y)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	363 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	364 octave_idx_type nr = x.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	365 octave_idx_type nc = x.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	366 SparseMatrix retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	367 double f_zero = f (0., y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	368
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	369 if (f_zero != 0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	370 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	371 retval = SparseMatrix (nr, nc, f_zero);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	372
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	373 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	374 for (octave_idx_type i = x.cidx (j); i < x.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	375 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	376 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	377 retval.data (x.ridx(i) + j * nr) = f (x.data (i), y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	378 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	379
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	380 retval.maybe_compress (true);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	381 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	382 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	383 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	384 octave_idx_type nz = x.nnz ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	385 retval = SparseMatrix (nr, nc, nz);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	386 octave_idx_type ii = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	387 retval.cidx (ii) = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	388
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	389 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	390 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	391 for (octave_idx_type i = x.cidx (j); i < x.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	392 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	393 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	394 double val = f (x.data (i), y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	395
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	396 if (val != 0.0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	397 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	398 retval.data (ii) = val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	399 retval.ridx (ii++) = x.ridx (i);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	400 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	401 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	402 retval.cidx (j + 1) = ii;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	403 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	404
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	405 retval.maybe_compress (false);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	406 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	407
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	408 return retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	409 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	410
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	411 static SparseMatrix
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	412 map_s_s (d_dd_fcn f, const SparseMatrix& x, const SparseMatrix& y)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	413 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	414 octave_idx_type nr = x.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	415 octave_idx_type nc = x.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	416
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	417 octave_idx_type y_nr = y.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	418 octave_idx_type y_nc = y.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	419
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	420 assert (nr == y_nr && nc == y_nc);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	421
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	422 SparseMatrix retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	423 double f_zero = f (0., 0.);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	424
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	425 if (f_zero != 0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	426 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	427 retval = SparseMatrix (nr, nc, f_zero);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	428 octave_idx_type k1 = 0, k2 = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	429
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	430 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	431 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	432 while (k1 < x.cidx(j+1) && k2 < y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	433 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	434 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	435 if (k1 >= x.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	436 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	437 retval.data (y.ridx(k2) + j * nr) = f (0.0, y.data (k2));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	438 k2++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	439 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	440 else if (k2 >= y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	441 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	442 retval.data (x.ridx(k1) + j * nr) = f (x.data (k1), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	443 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	444 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	445 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	446 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	447 octave_idx_type rx = x.ridx(k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	448 octave_idx_type ry = y.ridx(k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	449
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	450 if (rx < ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	451 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	452 retval.data (rx + j * nr) = f (x.data (k1), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	453 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	454 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	455 else if (rx > ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	456 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	457 retval.data (ry + j * nr) = f (0.0, y.data (k2));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	458 k2++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	459 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	460 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	461 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	462 retval.data (ry + j * nr) = f (x.data (k1), y.data (k2));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	463 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	464 k2++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	465 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	466 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	467 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	468 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	469
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	470 retval.maybe_compress (true);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	471 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	472 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	473 {
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	474 octave_idx_type nz = x.nnz () + y.nnz ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	475 retval = SparseMatrix (nr, nc, nz);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	476 octave_idx_type ii = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	477 retval.cidx (ii) = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	478 octave_idx_type k1 = 0, k2 = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	479
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	480 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	481 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	482 while (k1 < x.cidx(j+1) && k2 < y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	483 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	484 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	485 double val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	486 octave_idx_type r;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	487 if (k1 >= x.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	488 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	489 r = y.ridx (k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	490 val = f (0.0, y.data (k2++));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	491 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	492 else if (k2 >= y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	493 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	494 r = x.ridx (k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	495 val = f (x.data (k1++), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	496 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	497 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	498 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	499 octave_idx_type rx = x.ridx(k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	500 octave_idx_type ry = y.ridx(k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	501
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	502 if (rx < ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	503 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	504 r = x.ridx (k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	505 val = f (x.data (k1++), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	506 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	507 else if (rx > ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	508 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	509 r = y.ridx (k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	510 val = f (0.0, y.data (k2++));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	511 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	512 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	513 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	514 r = y.ridx (k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	515 val = f (x.data (k1++), y.data (k2++));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	516 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	517 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	518 if (val != 0.0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	519 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	520 retval.data (ii) = val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	521 retval.ridx (ii++) = r;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	522 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	523 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	524 retval.cidx (j + 1) = ii;
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	525 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	526
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	527 retval.maybe_compress (false);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	528 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	529
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	530 return retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	531 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	532
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	533 DEFUN (atan2, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	534 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	535 @deftypefn {Mapping Function} {} atan2 (@var{y}, @var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	536 Compute atan (@var{y} / @var{x}) for corresponding elements of @var{y}\n\
8347 fa78cb8d8a5c corrections for typos Brian Gough<bjg@network-theory.co.uk> parents: 8303 diff changeset	537 and @var{x}. The result is in the range -pi to pi.\n\
3439 3234a698073a [project @ 2000-01-14 09:51:14 by jwe] jwe parents: 3428 diff changeset	538 @end deftypefn")
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	539 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	540 octave_value retval;
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	541
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	542 int nargin = args.length ();
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	543
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	544 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	545 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	546 if (args(0).is_integer_type () \|\| args(1).is_integer_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	547 error ("atan2: not defined for integer types");
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	548 else
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	549 {
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	550 octave_value arg_y = args(0);
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	551 octave_value arg_x = args(1);
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	552
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	553 dim_vector y_dims = arg_y.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	554 dim_vector x_dims = arg_x.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	555
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	556 bool y_is_scalar = y_dims.all_ones ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	557 bool x_is_scalar = x_dims.all_ones ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	558
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	559 bool is_float = arg_y.is_single_type () \|\| arg_x.is_single_type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	560
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	561 if (y_is_scalar && x_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	562 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	563 if (is_float)
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	564 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	565 float y = arg_y.float_value ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	566
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	567 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	568 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	569 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	570
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	571 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	572 retval = atan2f (y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	573 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	574 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	575 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	576 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	577 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	578
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	579 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	580 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	581 double x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	582
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	583 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	584 retval = atan2 (y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	585 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	586 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	587 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	588 else if (y_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	589 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	590 if (is_float)
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	591 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	592 float y = arg_y.float_value ();
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	593
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	594 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	595 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	596 // Even if x is sparse return a full matrix here
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	597 FloatNDArray x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	598
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	599 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	600 retval = map_f_fm (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	601 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	602 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	603 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	604 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	605 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	606
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	607 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	608 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	609 // Even if x is sparse return a full matrix here
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	610 NDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	611
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	612 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	613 retval = map_d_m (atan2, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	614 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	615 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	616 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	617 else if (x_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	618 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	619 if (arg_y.is_sparse_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	620 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	621 SparseMatrix y = arg_y.sparse_matrix_value ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	622
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	623 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	624 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	625 double x = arg_x.double_value ();
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	626
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	627 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	628 retval = map_s_d (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	629 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	630 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	631 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	632 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	633 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	634
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	635 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	636 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	637 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	638
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	639 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	640 retval = map_fm_f (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	641 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	642 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	643 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	644 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	645 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	646
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	647 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	648 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	649 double x = arg_x.double_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	650
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	651 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	652 retval = map_m_d (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	653 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	654 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	655 }
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	656 else if (y_dims == x_dims)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	657 {
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	658 // Even if y is sparse return a full matrix here
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	659 if (arg_x.is_sparse_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	660 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	661 SparseMatrix y = arg_y.sparse_matrix_value ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	662
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	663 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	664 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	665 SparseMatrix x = arg_x.sparse_matrix_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	666
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	667 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	668 retval = map_s_s (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	669 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	670 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	671 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	672 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	673 FloatNDArray y = arg_y.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	674
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	675 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	676 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	677 FloatNDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	678
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	679 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	680 retval = map_fm_fm (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	681 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	682 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	683 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	684 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	685 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	686
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	687 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	688 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	689 NDArray x = arg_x.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	690
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	691 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	692 retval = map_m_m (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	693 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	694 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	695 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	696 else
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	697 error ("atan2: nonconformant matrices");
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	698 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	699 }
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	700 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	701 print_usage ();
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	702
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	703 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	704 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	705
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	706 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	707 %!assert (size (atan2 (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	708 %!assert (size (atan2 (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	709 %!assert (size (atan2 (rand (2, 3, 4), 1)), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	710 %!assert (size (atan2 (1, rand (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	711 %!assert (size (atan2 (1, 2)), [1, 1])
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	712
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	713 %!test
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	714 %! rt2 = sqrt (2);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	715 %! rt3 = sqrt (3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	716 %! v = [0, pi/6, pi/4, pi/3, -pi/3, -pi/4, -pi/6, 0];
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	717 %! y = [0, rt3, 1, rt3, -rt3, -1, -rt3, 0];
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	718 %! x = [1, 3, 1, 1, 1, 1, 3, 1];
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	719 %! assert(atan2 (y, x), v, sqrt (eps));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	720
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	721 %!test
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	722 %! rt2 = sqrt (2);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	723 %! rt3 = sqrt (3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	724 %! v = single([0, pi/6, pi/4, pi/3, -pi/3, -pi/4, -pi/6, 0]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	725 %! y = single([0, rt3, 1, rt3, -rt3, -1, -rt3, 0]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	726 %! x = single([1, 3, 1, 1, 1, 1, 3, 1]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	727 %! assert(atan2 (y, x), v, sqrt (eps('single')));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	728
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	729 %!error <Invalid call to atan2.*> atan2 ();
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	730 %!error <Invalid call to atan2.*> atan2 (1, 2, 3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	731
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	732 */
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	733
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	734
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	735
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	736 DEFUN (hypot, args, ,
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	737 "-- texinfo --\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	738 @deftypefn {Mapping Function} {} hypot (@var{x}, @var{y})\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	739 Compute square-root of the squares of @var{x} and @var{y}\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	740 element-by-element. This equivalent to @code{sqrt (@var{x}.^ 2 + @var{y}\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	741 .^ 2)}, but calculated in a manner that avoids overflows for large\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	742 values of @var{x} or @var{y}.\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	743 @end deftypefn")
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	744 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	745 octave_value retval;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	746
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	747 int nargin = args.length ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	748
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	749 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	750 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	751 if (args(0).is_integer_type () \|\| args(1).is_integer_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	752 error ("hypot: not defined for integer types");
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	753 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	754 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	755 octave_value arg_x = args(0);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	756 octave_value arg_y = args(1);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	757
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	758 dim_vector x_dims = arg_x.dims ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	759 dim_vector y_dims = arg_y.dims ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	760
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	761 bool x_is_scalar = x_dims.all_ones ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	762 bool y_is_scalar = y_dims.all_ones ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	763
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	764 bool is_float = arg_y.is_single_type () \|\| arg_x.is_single_type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	765
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	766 if (y_is_scalar && x_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	767 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	768 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	769 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	770 float x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	771 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	772 x = abs (arg_x.float_complex_value ());
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	773 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	774 x = arg_x.float_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	775
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	776 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	777 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	778 float y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	779 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	780 y = abs (arg_y.float_complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	781 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	782 y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	783
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	784 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	785 retval = hypotf (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	786 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	787 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	788 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	789 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	790 double x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	791 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	792 x = abs (arg_x.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	793 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	794 x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	795
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	796 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	797 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	798 double y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	799 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	800 y = abs (arg_y.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	801 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	802 y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	803
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	804 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	805 retval = hypot (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	806 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	807 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	808 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	809 else if (y_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	810 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	811 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	812 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	813 FloatNDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	814 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	815 x = arg_x.float_complex_array_value ().abs ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	816 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	817 x = arg_x.float_array_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	818
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	819 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	820 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	821 float y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	822 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	823 y = abs (arg_y.float_complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	824 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	825 y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	826
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	827 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	828 retval = map_fm_f (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	829 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	830 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	831 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	832 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	833 NDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	834 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	835 x = arg_x.complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	836 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	837 x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	838
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	839 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	840 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	841 double y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	842 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	843 y = abs (arg_y.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	844 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	845 y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	846
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	847 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	848 retval = map_m_d (hypot, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	849 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	850 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	851 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	852 else if (x_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	853 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	854 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	855 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	856 float x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	857 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	858 x = abs (arg_x.float_complex_value ());
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	859 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	860 x = arg_x.float_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	861
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	862 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	863 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	864 FloatNDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	865 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	866 y = arg_y.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	867 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	868 y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	869
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	870 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	871 retval = map_f_fm (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	872 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	873 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	874 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	875 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	876 double x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	877 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	878 x = abs (arg_x.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	879 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	880 x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	881
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	882 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	883 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	884 NDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	885 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	886 y = arg_y.complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	887 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	888 y = arg_y.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	889
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	890 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	891 retval = map_d_m (hypot, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	892 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	893 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	894 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	895 else if (y_dims == x_dims)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	896 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	897 if (arg_x.is_sparse_type () && arg_y.is_sparse_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	898 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	899 SparseMatrix x;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	900 if (arg_x.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	901 x = arg_x.sparse_complex_matrix_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	902 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	903 x = arg_x.sparse_matrix_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	904
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	905 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	906 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	907 SparseMatrix y;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	908 if (arg_y.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	909 y = arg_y.sparse_complex_matrix_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	910 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	911 y = arg_y.sparse_matrix_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	912
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	913 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	914 retval = map_s_s (hypot, x, y);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	915 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	916 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	917 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	918 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	919 FloatNDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	920 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	921 x = arg_x.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	922 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	923 x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	924
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	925 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	926 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	927 FloatNDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	928 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	929 y = arg_y.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	930 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	931 y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	932
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	933 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	934 retval = map_fm_fm (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	935 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	936 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	937 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	938 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	939 NDArray x;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	940 if (arg_x.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	941 x = arg_x.complex_array_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	942 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	943 x = arg_x.array_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	944
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	945 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	946 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	947 NDArray y;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	948 if (arg_y.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	949 y = arg_y.complex_array_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	950 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	951 y = arg_y.array_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	952
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	953 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	954 retval = map_m_m (hypot, x, y);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	955 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	956 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	957 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	958 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	959 error ("hypot: nonconformant matrices");
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	960 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	961 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	962 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	963 print_usage ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	964
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	965 return retval;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	966 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	967
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	968 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	969 %!assert (size (hypot (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	970 %!assert (size (hypot (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	971 %!assert (size (hypot (rand (2, 3, 4), 1)), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	972 %!assert (size (hypot (1, rand (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	973 %!assert (size (hypot (1, 2)), [1, 1])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	974 %!assert (hypot (1:10, 1:10), sqrt(2) * [1:10], 16*eps)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	975 %!assert (hypot (single(1:10), single(1:10)), single(sqrt(2) * [1:10]));
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	976 */
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	977
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	978 template<typename T, typename ET>
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	979 void
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	980 map_2_xlog2 (const Array<T>& x, Array<T>& f, Array<ET>& e)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	981 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	982 f = Array<T>(x.dims ());
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	983 e = Array<ET>(x.dims ());
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	984 for (octave_idx_type i = 0; i < x.numel (); i++)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	985 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	986 int exp;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	987 f.xelem (i) = xlog2 (x(i), exp);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	988 e.xelem (i) = exp;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	989 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	990 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	991
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	992 DEFUN (log2, args, nargout,
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	993 "-- texinfo --\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	994 @deftypefn {Mapping Function} {} log2 (@var{x})\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	995 @deftypefnx {Mapping Function} {[@var{f}, @var{e}] = } log2 (@var{x})\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	996 Compute the base-2 logarithm for each element of @var{x}.\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	997 If called with two output arguments, split @var{x} to\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	998 binary mantissa and exponent so that @code{1/2 <= abs(f) < 1} and\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	999 @var{e} is an integer. If @code{x = 0}, @code{f = e = 0}.\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1000 @seealso{log, log10, log2, exp}\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1001 @end deftypefn")
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1002 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1003 octave_value_list retval;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1004
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1005 if (args.length () == 1)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1006 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1007 if (nargout < 2)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1008 retval(0) = args(0).log2 ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1009 else if (args(0).is_single_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1010 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1011 if (args(0).is_real_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1012 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1013 FloatNDArray f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1014 FloatNDArray x = args(0).float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1015 // FIXME -- should E be an int value?
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1016 FloatMatrix e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1017 map_2_xlog2 (x, f, e);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1018 retval (1) = e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1019 retval (0) = f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1020 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1021 else if (args(0).is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1022 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1023 FloatComplexNDArray f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1024 FloatComplexNDArray x = args(0).float_complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1025 // FIXME -- should E be an int value?
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1026 FloatNDArray e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1027 map_2_xlog2 (x, f, e);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1028 retval (1) = e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1029 retval (0) = f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1030 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1031 }
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1032 else if (args(0).is_real_type ())
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1033 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1034 NDArray f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1035 NDArray x = args(0).array_value ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1036 // FIXME -- should E be an int value?
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1037 Matrix e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1038 map_2_xlog2 (x, f, e);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1039 retval (1) = e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1040 retval (0) = f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1041 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1042 else if (args(0).is_complex_type ())
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1043 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1044 ComplexNDArray f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1045 ComplexNDArray x = args(0).complex_array_value ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1046 // FIXME -- should E be an int value?
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1047 NDArray e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1048 map_2_xlog2 (x, f, e);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1049 retval (1) = e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1050 retval (0) = f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1051 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1052 else
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1053 gripe_wrong_type_arg ("log2", args(0));
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1054 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1055 else
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1056 print_usage ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1057
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1058 return retval;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1059 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1060
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1061 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1062 %!assert(log2 ([1/4, 1/2, 1, 2, 4]), [-2, -1, 0, 1, 2]);
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1063 %!assert(log2(Inf), Inf);
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1064 %!assert(isnan(log2(NaN)));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1065 %!assert(log2(4i), 2 + log2(1i));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1066 %!assert(log2(complex(0,Inf)), Inf + log2(i));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1067
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1068 %!test
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1069 %! [f, e] = log2 ([0,-1; 2,-4; Inf,-Inf]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1070 %! assert (f, [0,-0.5; 0.5,-0.5; Inf,-Inf]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1071 %! assert (e, [0,1;2,3;0,0])
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1072
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1073 %!test
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1074 %! [f, e] = log2 (complex (zeros (3, 2), [0,-1; 2,-4; Inf,-Inf]));
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1075 %! assert (f, complex (zeros (3, 2), [0,-0.5; 0.5,-0.5; Inf,-Inf]));
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1076 %! assert (e, [0,1; 2,3; 0,0]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1077 */
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1078
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1079 DEFUN (fmod, args, ,
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1080 "-- texinfo --\n\
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1081 @deftypefn {Mapping Function} {} fmod (@var{x}, @var{y})\n\
4685 14a1c9f42f67 [project @ 2004-01-06 17:20:02 by jwe] jwe parents: 4593 diff changeset	1082 Compute the floating point remainder of dividing @var{x} by @var{y}\n\
14a1c9f42f67 [project @ 2004-01-06 17:20:02 by jwe] jwe parents: 4593 diff changeset	1083 using the C library function @code{fmod}. The result has the same\n\
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1084 sign as @var{x}. If @var{y} is zero, the result is implementation-defined.\n\
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1085 @end deftypefn")
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1086 {
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1087 octave_value retval;
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1088
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1089 int nargin = args.length ();
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1090
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1091 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1092 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1093 octave_value arg_y = args(0);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1094 octave_value arg_x = args(1);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1095
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1096 dim_vector y_dims = arg_y.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1097 dim_vector x_dims = arg_x.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1098
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1099 bool y_is_scalar = y_dims.all_ones ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1100 bool x_is_scalar = x_dims.all_ones ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1101
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1102 bool is_float = arg_y.is_single_type () \|\| arg_x.is_single_type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1103
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1104 if (y_is_scalar && x_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1105 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1106 if (is_float)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1107 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1108 float y = arg_y.float_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1109
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1110 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1111 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1112 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1113
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1114 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1115 retval = fmod (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1116 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1117 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1118 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1119 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1120 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1121
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1122 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1123 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1124 double x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1125
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1126 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1127 retval = fmod (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1128 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1129 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1130 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1131 else if (y_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1132 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1133 if (is_float)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1134 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1135 float y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1136
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1137 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1138 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1139 FloatNDArray x = arg_x.float_array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1140
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1141 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1142 retval = map_fm_f (fmodf, x, y);
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1143 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1144 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1145 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1146 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1147 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1148
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1149 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1150 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1151 if (arg_x.is_sparse_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1152 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1153 SparseMatrix x = arg_x.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1154
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1155 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1156 retval = map_s_d (fmod, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1157 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1158 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1159 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1160 NDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1161
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1162 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1163 retval = map_m_d (fmod, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1164 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1165 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1166 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1167 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1168 else if (x_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1169 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1170 if (arg_y.is_sparse_type ())
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1171 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1172 SparseMatrix y = arg_y.sparse_matrix_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1173
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1174 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1175 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1176 double x = arg_x.double_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1177
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1178 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1179 retval = map_d_s (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1180 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1181 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1182 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1183 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1184 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1185
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1186 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1187 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1188 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1189
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1190 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1191 retval = map_f_fm (fmodf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1192 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1193 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1194 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1195 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1196 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1197
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1198 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1199 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1200 double x = arg_x.double_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1201
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1202 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1203 retval = map_d_m (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1204 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1205 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1206 }
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1207 else if (y_dims == x_dims)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1208 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1209 if (arg_y.is_sparse_type () \|\| arg_x.is_sparse_type ())
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1210 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1211 SparseMatrix y = arg_y.sparse_matrix_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1212
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1213 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1214 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1215 SparseMatrix x = arg_x.sparse_matrix_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1216
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1217 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1218 retval = map_s_s (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1219 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1220 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1221 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1222 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1223 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1224
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1225 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1226 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1227 FloatNDArray x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1228
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1229 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1230 retval = map_fm_fm (fmodf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1231 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1232 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1233 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1234 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1235 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1236
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1237 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1238 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1239 NDArray x = arg_x.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1240
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1241 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1242 retval = map_m_m (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1243 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1244 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1245 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1246 else
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1247 error ("fmod: nonconformant matrices");
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1248 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1249 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1250 print_usage ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1251
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1252 return retval;
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1253 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1254
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1255 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1256 %!assert (size (fmod (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1257 %!assert (size (fmod (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4])
7743 fbe27e477578 more tests fixed John W. Eaton <jwe@octave.org> parents: 7741 diff changeset	1258 %!assert (size (fmod (rand (2, 3, 4), 1)), [2, 3, 4])
fbe27e477578 more tests fixed John W. Eaton <jwe@octave.org> parents: 7741 diff changeset	1259 %!assert (size (fmod (1, rand (2, 3, 4))), [2, 3, 4])
fbe27e477578 more tests fixed John W. Eaton <jwe@octave.org> parents: 7741 diff changeset	1260 %!assert (size (fmod (1, 2)), [1, 1])
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1261 */
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1262
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1263 // FIXME Need to convert the reduction functions of this file for single precision
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1264
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1265 #define NATIVE_REDUCTION_1(FCN, TYPE, DIM) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1266 (arg.is_ ## TYPE ## _type ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1267 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1268 TYPE ## NDArray tmp = arg. TYPE ##_array_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1269 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1270 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1271 retval = tmp.FCN (DIM); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1272 }
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1273
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1274 #define NATIVE_REDUCTION(FCN) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1275 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1276 octave_value retval; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1277 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1278 int nargin = args.length (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1279 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1280 bool isnative = false; \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1281 bool isdouble = false; \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1282 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1283 if (nargin > 1 && args(nargin - 1).is_string ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1284 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1285 std::string str = args(nargin - 1).string_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1286 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1287 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1288 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1289 if (str == "native") \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1290 isnative = true; \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1291 else if (str == "double") \
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1292 isdouble = true; \
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1293 else \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1294 error ("sum: unrecognized string argument"); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1295 nargin --; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1296 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1297 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1298 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1299 if (nargin == 1 \|\| nargin == 2) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1300 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1301 octave_value arg = args(0); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1302 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1303 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1304 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1305 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1306 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1307 if (dim >= -1) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1308 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1309 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1310 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1311 if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1312 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1313 SparseMatrix tmp = arg.sparse_matrix_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1314 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1315 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1316 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1317 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1318 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1319 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1320 SparseComplexMatrix tmp = arg.sparse_complex_matrix_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1321 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1322 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1323 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1324 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1325 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1326 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1327 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1328 if (isnative) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1329 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1330 if NATIVE_REDUCTION_1 (FCN, uint8, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1331 else if NATIVE_REDUCTION_1 (FCN, uint16, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1332 else if NATIVE_REDUCTION_1 (FCN, uint32, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1333 else if NATIVE_REDUCTION_1 (FCN, uint64, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1334 else if NATIVE_REDUCTION_1 (FCN, int8, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1335 else if NATIVE_REDUCTION_1 (FCN, int16, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1336 else if NATIVE_REDUCTION_1 (FCN, int32, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1337 else if NATIVE_REDUCTION_1 (FCN, int64, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1338 else if NATIVE_REDUCTION_1 (FCN, bool, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1339 else if (arg.is_char_matrix ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1340 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1341 error (#FCN, ": invalid char type"); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1342 } \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1343 else if (!isdouble && arg.is_single_type ()) \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1344 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1345 if (arg.is_complex_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1346 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1347 FloatComplexNDArray tmp = \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1348 arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1349 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1350 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1351 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1352 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1353 else if (arg.is_real_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1354 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1355 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1356 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1357 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1358 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1359 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1360 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1361 else if (arg.is_complex_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1362 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1363 ComplexNDArray tmp = arg.complex_array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1364 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1365 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1366 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1367 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1368 else if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1369 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1370 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1371 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1372 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1373 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1374 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1375 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1376 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1377 gripe_wrong_type_arg (#FCN, arg); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1378 return retval; \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1379 } \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1380 } \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1381 else if (!isdouble && arg.is_single_type ()) \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1382 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1383 if (arg.is_real_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1384 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1385 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1386 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1387 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1388 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1389 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1390 else if (arg.is_complex_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1391 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1392 FloatComplexNDArray tmp = \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1393 arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1394 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1395 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1396 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1397 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1398 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1399 else if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1400 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1401 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1402 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1403 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1404 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1405 } \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1406 else if (arg.is_complex_type ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1407 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1408 ComplexNDArray tmp = arg.complex_array_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1409 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1410 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1411 retval = tmp.FCN (dim); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1412 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1413 else \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1414 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1415 gripe_wrong_type_arg (#FCN, arg); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1416 return retval; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1417 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1418 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1419 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1420 else \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1421 error (#FCN ": invalid dimension argument = %d", dim + 1); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1422 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1423 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1424 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1425 else \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1426 print_usage (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1427 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1428 return retval
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1429
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1430 #define DATA_REDUCTION(FCN) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1431 \
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	1432 octave_value retval; \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1433 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1434 int nargin = args.length (); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1435 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1436 if (nargin == 1 \|\| nargin == 2) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1437 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1438 octave_value arg = args(0); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1439 \
3864 e78705239df5 [project @ 2001-11-16 12:56:20 by jwe] jwe parents: 3797 diff changeset	1440 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1441 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1442 if (! error_state) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1443 { \
4556 773a21e4fce8 [project @ 2003-10-28 05:02:10 by jwe] jwe parents: 4554 diff changeset	1444 if (dim >= -1) \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1445 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1446 if (arg.is_real_type ()) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1447 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1448 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1449 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1450 SparseMatrix tmp = arg.sparse_matrix_value (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1451 \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1452 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1453 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1454 } \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1455 else if (arg.is_single_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1456 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1457 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1458 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1459 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1460 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1461 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1462 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1463 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1464 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1465 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1466 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1467 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1468 } \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1469 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1470 else if (arg.is_complex_type ()) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1471 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1472 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1473 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1474 SparseComplexMatrix tmp = arg.sparse_complex_matrix_value (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1475 \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1476 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1477 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1478 } \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1479 else if (arg.is_single_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1480 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1481 FloatComplexNDArray tmp = arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1482 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1483 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1484 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1485 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1486 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1487 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1488 ComplexNDArray tmp = arg.complex_array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1489 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1490 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1491 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1492 } \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1493 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1494 else \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1495 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1496 gripe_wrong_type_arg (#FCN, arg); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1497 return retval; \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1498 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1499 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1500 else \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1501 error (#FCN ": invalid dimension argument = %d", dim + 1); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1502 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1503 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1504 else \
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1505 print_usage (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1506 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1507 return retval
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1508
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1509 DEFUN (cumprod, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1510 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1511 @deftypefn {Built-in Function} {} cumprod (@var{x}, @var{dim})\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1512 Cumulative product of elements along dimension @var{dim}. If\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1513 @var{dim} is omitted, it defaults to 1 (column-wise cumulative\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1514 products).\n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1515 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1516 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1517 return the cumulative product of the elements as a vector with the\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1518 same orientation as @var{x}.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1519 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1520 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1521 DATA_REDUCTION (cumprod);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1522 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1523
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1524 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1525
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1526 %!assert (cumprod ([1, 2, 3]), [1, 2, 6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1527 %!assert (cumprod ([-1; -2; -3]), [-1; 2; -6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1528 %!assert (cumprod ([i, 2+i, -3+2i, 4]), [i, -1+2i, -1-8i, -4-32i]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1529 %!assert (cumprod ([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i]), [1, 2, 3; i, 4i, 9i; -1+i, -8+8i, -27+27i]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1530
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1531 %!assert (cumprod (single([1, 2, 3])), single([1, 2, 6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1532 %!assert (cumprod (single([-1; -2; -3])), single([-1; 2; -6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1533 %!assert (cumprod (single([i, 2+i, -3+2i, 4])), single([i, -1+2i, -1-8i, -4-32i]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1534 %!assert (cumprod (single([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i])), single([1, 2, 3; i, 4i, 9i; -1+i, -8+8i, -27+27i]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1535
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1536 %!error <Invalid call to cumprod.*> cumprod ();
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1537
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1538 %!assert (cumprod ([2, 3; 4, 5], 1), [2, 3; 8, 15]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1539 %!assert (cumprod ([2, 3; 4, 5], 2), [2, 6; 4, 20]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1540
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1541 %!assert (cumprod (single([2, 3; 4, 5]), 1), single([2, 3; 8, 15]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1542 %!assert (cumprod (single([2, 3; 4, 5]), 2), single([2, 6; 4, 20]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1543
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1544 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1545
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1546 DEFUN (cumsum, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1547 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1548 @deftypefn {Built-in Function} {} cumsum (@var{x}, @var{dim})\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1549 Cumulative sum of elements along dimension @var{dim}. If @var{dim}\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1550 is omitted, it defaults to 1 (column-wise cumulative sums).\n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1551 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1552 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1553 return the cumulative sum of the elements as a vector with the\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1554 same orientation as @var{x}.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1555 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1556 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1557 DATA_REDUCTION (cumsum);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1558 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1559
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1560 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1561
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1562 %!assert (cumsum ([1, 2, 3]), [1, 3, 6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1563 %!assert (cumsum ([-1; -2; -3]), [-1; -3; -6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1564 %!assert (cumsum ([i, 2+i, -3+2i, 4]), [i, 2+2i, -1+4i, 3+4i]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1565 %!assert (cumsum ([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i]), [1, 2, 3; 1+i, 2+2i, 3+3i; 2+2i, 4+4i, 6+6i]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1566
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1567 %!assert (cumsum (single([1, 2, 3])), single([1, 3, 6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1568 %!assert (cumsum (single([-1; -2; -3])), single([-1; -3; -6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1569 %!assert (cumsum (single([i, 2+i, -3+2i, 4])), single([i, 2+2i, -1+4i, 3+4i]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1570 %!assert (cumsum (single([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i])), single([1, 2, 3; 1+i, 2+2i, 3+3i; 2+2i, 4+4i, 6+6i]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1571
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1572 %!error <Invalid call to cumsum.*> cumsum ();
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1573
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1574 %!assert (cumsum ([1, 2; 3, 4], 1), [1, 2; 4, 6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1575 %!assert (cumsum ([1, 2; 3, 4], 2), [1, 3; 3, 7]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1576
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1577 %!assert (cumsum (single([1, 2; 3, 4]), 1), single([1, 2; 4, 6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1578 %!assert (cumsum (single([1, 2; 3, 4]), 2), single([1, 3; 3, 7]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1579
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1580 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1581
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1582 DEFUN (diag, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1583 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1584 @deftypefn {Built-in Function} {} diag (@var{v}, @var{k})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1585 Return a diagonal matrix with vector @var{v} on diagonal @var{k}. The\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1586 second argument is optional. If it is positive, the vector is placed on\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1587 the @var{k}-th super-diagonal. If it is negative, it is placed on the\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1588 @var{-k}-th sub-diagonal. The default value of @var{k} is 0, and the\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1589 vector is placed on the main diagonal. For example,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1590 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1591 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1592 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1593 diag ([1, 2, 3], 1)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1594 @result{} 0 1 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1595 0 0 2 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1596 0 0 0 3\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1597 0 0 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1598 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1599 @end example\n\
6772 315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1600 \n\
315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1601 @noindent\n\
315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1602 Given a matrix argument, instead of a vector, @code{diag} extracts the\n\
6774 3b09c87d5165 [project @ 2007-07-13 13:27:36 by dbateman] dbateman parents: 6772 diff changeset	1603 @var{k}-th diagonal of the matrix.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1604 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1605 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	1606 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1607
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1608 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1609
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	1610 if (nargin == 1 && args(0).is_defined ())
7620 36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1611 retval = args(0).diag();
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	1612 else if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
7620 36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1613 {
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1614 octave_idx_type k = args(1).int_value ();
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1615
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1616 if (error_state)
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1617 error ("diag: invalid second argument");
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1618 else
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1619 retval = args(0).diag(k);
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1620 }
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1621 else if (nargin == 3)
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1622 {
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1623 octave_value arg0 = args(0);
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1624 if (arg0.ndims () == 2 && (args(0).rows () == 1 \|\| args(0).columns () == 1))
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1625 {
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1626 octave_idx_type m = args(1).int_value (), n = args(2).int_value ();
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1627 if (! error_state)
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1628 retval = arg0.diag ().resize (dim_vector (m, n));
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1629 else
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1630 error ("diag: invalid dimensions");
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1631 }
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1632 else
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1633 error ("diag: first argument must be a vector");
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1634 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1635 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1636 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1637
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1638 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1639 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1640
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1641 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1642
8459 d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1643 %!assert(full (diag ([1; 2; 3])), [1, 0, 0; 0, 2, 0; 0, 0, 3]);
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1644 %!assert(diag ([1; 2; 3], 1), [0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1645 %!assert(diag ([1; 2; 3], 2), [0, 0, 1, 0, 0; 0, 0, 0, 2, 0; 0, 0, 0, 0, 3; 0, 0, 0, 0, 0; 0, 0, 0, 0, 0]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1646 %!assert(diag ([1; 2; 3],-1), [0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1647 %!assert(diag ([1; 2; 3],-2), [0, 0, 0, 0, 0; 0, 0, 0, 0, 0; 1, 0, 0, 0, 0; 0, 2, 0, 0, 0; 0, 0, 3, 0, 0]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1648
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1649 %!assert(diag ([1, 0, 0; 0, 2, 0; 0, 0, 3]), [1; 2; 3]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1650 %!assert(diag ([0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0], 1), [1; 2; 3]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1651 %!assert(diag ([0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0], -1), [1; 2; 3]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1652
8459 d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1653 %!assert(full (diag (single([1; 2; 3]))), single([1, 0, 0; 0, 2, 0; 0, 0, 3]));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1654 %!assert(diag (single([1; 2; 3]), 1), single([0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1655 %!assert(diag (single([1; 2; 3]), 2), single([0, 0, 1, 0, 0; 0, 0, 0, 2, 0; 0, 0, 0, 0, 3; 0, 0, 0, 0, 0; 0, 0, 0, 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1656 %!assert(diag (single([1; 2; 3]),-1), single([0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1657 %!assert(diag (single([1; 2; 3]),-2), single([0, 0, 0, 0, 0; 0, 0, 0, 0, 0; 1, 0, 0, 0, 0; 0, 2, 0, 0, 0; 0, 0, 3, 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1658
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1659 %!assert(diag (single([1, 0, 0; 0, 2, 0; 0, 0, 3])), single([1; 2; 3]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1660 %!assert(diag (single([0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0]), 1), single([1; 2; 3]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1661 %!assert(diag (single([0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0]), -1), single([1; 2; 3]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1662
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1663 %!assert(diag (int8([1; 2; 3])), int8([1, 0, 0; 0, 2, 0; 0, 0, 3]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1664 %!assert(diag (int8([1; 2; 3]), 1), int8([0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1665 %!assert(diag (int8([1; 2; 3]), 2), int8([0, 0, 1, 0, 0; 0, 0, 0, 2, 0; 0, 0, 0, 0, 3; 0, 0, 0, 0, 0; 0, 0, 0, 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1666 %!assert(diag (int8([1; 2; 3]),-1), int8([0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1667 %!assert(diag (int8([1; 2; 3]),-2), int8([0, 0, 0, 0, 0; 0, 0, 0, 0, 0; 1, 0, 0, 0, 0; 0, 2, 0, 0, 0; 0, 0, 3, 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1668
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1669 %!assert(diag (int8([1, 0, 0; 0, 2, 0; 0, 0, 3])), int8([1; 2; 3]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1670 %!assert(diag (int8([0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0]), 1), int8([1; 2; 3]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1671 %!assert(diag (int8([0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0]), -1), int8([1; 2; 3]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1672
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1673 %!error <Invalid call to diag.*> diag ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1674
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1675 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1676
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1677 DEFUN (prod, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1678 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1679 @deftypefn {Built-in Function} {} prod (@var{x}, @var{dim})\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1680 Product of elements along dimension @var{dim}. If @var{dim} is\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1681 omitted, it defaults to 1 (column-wise products).\n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1682 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1683 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1684 return the product of the elements.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1685 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1686 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1687 DATA_REDUCTION (prod);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1688 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1689
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1690 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1691
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1692 %!assert (prod ([1, 2, 3]), 6);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1693 %!assert (prod ([-1; -2; -3]), -6);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1694 %!assert (prod ([i, 2+i, -3+2i, 4]), -4 - 32i);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1695 %!assert (prod ([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i]), [-1+i, -8+8i, -27+27i]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1696
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1697 %!assert (prod (single([1, 2, 3])), single(6));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1698 %!assert (prod (single([-1; -2; -3])), single(-6));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1699 %!assert (prod (single([i, 2+i, -3+2i, 4])), single(-4 - 32i));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1700 %!assert (prod (single([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i])), single([-1+i, -8+8i, -27+27i]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1701
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1702 %!error <Invalid call to prod.*> prod ();
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1703
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1704 %!assert (prod ([1, 2; 3, 4], 1), [3, 8]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1705 %!assert (prod ([1, 2; 3, 4], 2), [2; 12]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1706 %!assert (prod (zeros (1, 0)), 1);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1707 %!assert (prod (zeros (1, 0), 1), zeros (1, 0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1708 %!assert (prod (zeros (1, 0), 2), 1);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1709 %!assert (prod (zeros (0, 1)), 1);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1710 %!assert (prod (zeros (0, 1), 1), 1);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1711 %!assert (prod (zeros (0, 1), 2), zeros (0, 1));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1712 %!assert (prod (zeros (2, 0)), zeros (1, 0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1713 %!assert (prod (zeros (2, 0), 1), zeros (1, 0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1714 %!assert (prod (zeros (2, 0), 2), [1; 1]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1715 %!assert (prod (zeros (0, 2)), [1, 1]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1716 %!assert (prod (zeros (0, 2), 1), [1, 1]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1717 %!assert (prod (zeros (0, 2), 2), zeros(0, 1));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1718
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1719 %!assert (prod (single([1, 2; 3, 4]), 1), single([3, 8]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1720 %!assert (prod (single([1, 2; 3, 4]), 2), single([2; 12]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1721 %!assert (prod (zeros (1, 0, 'single')), single(1));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1722 %!assert (prod (zeros (1, 0, 'single'), 1), zeros (1, 0, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1723 %!assert (prod (zeros (1, 0, 'single'), 2), single(1));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1724 %!assert (prod (zeros (0, 1, 'single')), single(1));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1725 %!assert (prod (zeros (0, 1, 'single'), 1), single(1));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1726 %!assert (prod (zeros (0, 1, 'single'), 2), zeros (0, 1, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1727 %!assert (prod (zeros (2, 0, 'single')), zeros (1, 0, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1728 %!assert (prod (zeros (2, 0, 'single'), 1), zeros (1, 0, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1729 %!assert (prod (zeros (2, 0, 'single'), 2), single([1; 1]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1730 %!assert (prod (zeros (0, 2, 'single')), single([1, 1]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1731 %!assert (prod (zeros (0, 2, 'single'), 1), single([1, 1]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1732 %!assert (prod (zeros (0, 2, 'single'), 2), zeros(0, 1, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1733
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1734 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1735
8107 8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1736 #define SINGLE_TYPE_CONCAT(TYPE, EXTRACTOR) \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1737 do \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1738 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1739 int dv_len = dv.length (); \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1740 Array<octave_idx_type> ra_idx (dv_len > 1 ? dv_len : 2, 0); \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1741 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1742 for (int j = 1; j < n_args; j++) \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1743 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1744 OCTAVE_QUIT; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1745 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1746 TYPE ra = args(j).EXTRACTOR (); \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1747 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1748 if (! error_state) \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1749 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1750 result.insert (ra, ra_idx); \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1751 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1752 if (error_state) \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1753 return retval; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1754 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1755 dim_vector dv_tmp = args (j).dims (); \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1756 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1757 if (dim >= dv_len) \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1758 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1759 if (j > 1) \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1760 error ("%s: indexing error", fname.c_str ()); \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1761 break; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1762 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1763 else \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1764 ra_idx (dim) += (dim < dv_tmp.length () ? dv_tmp (dim) : 1); \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1765 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1766 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1767 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1768 while (0)
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1769
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1770 #define DO_SINGLE_TYPE_CONCAT(TYPE, EXTRACTOR) \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1771 do \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1772 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1773 TYPE result (dv); \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1774 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1775 SINGLE_TYPE_CONCAT(TYPE, EXTRACTOR); \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1776 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1777 retval = result; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1778 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1779 while (0)
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1780
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1781 static octave_value
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1782 do_cat (const octave_value_list& args, std::string fname)
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1783 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1784 octave_value retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1785
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1786 int n_args = args.length ();
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1787
5714 24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1788 if (n_args == 1)
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1789 retval = Matrix ();
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1790 else if (n_args == 2)
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1791 retval = args(1);
5507 273612001e3a [project @ 2005-10-26 08:01:24 by dbateman] dbateman parents: 5476 diff changeset	1792 else if (n_args > 2)
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1793 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1794 octave_idx_type dim = args(0).int_value () - 1;
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1795
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1796 if (error_state)
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1797 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1798 error ("cat: expecting first argument to be a integer");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1799 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1800 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1801
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1802 if (dim >= 0)
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1803 {
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1804
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1805 dim_vector dv = args(1).dims ();
8107 8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1806 std::string result_type = args(1).class_name ();
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1807
8107 8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1808 bool all_sq_strings_p = args(1).is_sq_string ();
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1809 bool all_dq_strings_p = args(1).is_dq_string ();
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1810 bool all_real_p = args(1).is_real_type ();
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1811 bool any_sparse_p = args(1).is_sparse_type();
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1812
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1813 for (int i = 2; i < args.length (); i++)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1814 {
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1815 // add_dims constructs a dimension vector which holds the
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1816 // dimensions of the final array after concatenation.
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1817
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1818 if (! dv.concat (args(i).dims (), dim))
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1819 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1820 // Dimensions do not match.
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1821 error ("cat: dimension mismatch");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1822 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1823 }
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1824
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1825 result_type =
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1826 get_concat_class (result_type, args(i).class_name ());
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1827
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1828 if (all_sq_strings_p && ! args(i).is_sq_string ())
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1829 all_sq_strings_p = false;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1830 if (all_dq_strings_p && ! args(i).is_dq_string ())
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1831 all_dq_strings_p = false;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1832 if (all_real_p && ! args(i).is_real_type ())
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1833 all_real_p = false;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1834 if (!any_sparse_p && args(i).is_sparse_type ())
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1835 any_sparse_p = true;
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1836 }
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1837
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1838 if (result_type == "double")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1839 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1840 if (any_sparse_p)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1841 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1842 if (all_real_p)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1843 DO_SINGLE_TYPE_CONCAT (SparseMatrix, sparse_matrix_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1844 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1845 DO_SINGLE_TYPE_CONCAT (SparseComplexMatrix, sparse_complex_matrix_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1846 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1847 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1848 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1849 if (all_real_p)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1850 DO_SINGLE_TYPE_CONCAT (NDArray, array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1851 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1852 DO_SINGLE_TYPE_CONCAT (ComplexNDArray, complex_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1853 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1854 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1855 else if (result_type == "single")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1856 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1857 if (all_real_p)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1858 DO_SINGLE_TYPE_CONCAT (FloatNDArray, float_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1859 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1860 DO_SINGLE_TYPE_CONCAT (FloatComplexNDArray,
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1861 float_complex_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1862 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1863 else if (result_type == "char")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1864 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1865 char type = all_dq_strings_p ? '"' : '\'';
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1866
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1867 maybe_warn_string_concat (all_dq_strings_p, all_sq_strings_p);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1868
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1869 charNDArray result (dv, Vstring_fill_char);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1870
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1871 SINGLE_TYPE_CONCAT (charNDArray, char_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1872
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1873 retval = octave_value (result, true, type);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1874 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1875 else if (result_type == "logical")
5533 667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1876 {
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1877 if (any_sparse_p)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1878 DO_SINGLE_TYPE_CONCAT (SparseBoolMatrix, sparse_bool_matrix_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1879 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1880 DO_SINGLE_TYPE_CONCAT (boolNDArray, bool_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1881 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1882 else if (result_type == "int8")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1883 DO_SINGLE_TYPE_CONCAT (int8NDArray, int8_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1884 else if (result_type == "int16")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1885 DO_SINGLE_TYPE_CONCAT (int16NDArray, int16_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1886 else if (result_type == "int32")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1887 DO_SINGLE_TYPE_CONCAT (int32NDArray, int32_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1888 else if (result_type == "int64")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1889 DO_SINGLE_TYPE_CONCAT (int64NDArray, int64_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1890 else if (result_type == "uint8")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1891 DO_SINGLE_TYPE_CONCAT (uint8NDArray, uint8_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1892 else if (result_type == "uint16")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1893 DO_SINGLE_TYPE_CONCAT (uint16NDArray, uint16_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1894 else if (result_type == "uint32")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1895 DO_SINGLE_TYPE_CONCAT (uint32NDArray, uint32_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1896 else if (result_type == "uint64")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1897 DO_SINGLE_TYPE_CONCAT (uint64NDArray, uint64_array_value);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1898 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1899 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1900 // The lines below might seem crazy, since we take a copy
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1901 // of the first argument, resize it to be empty and then resize
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1902 // it to be full. This is done since it means that there is no
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1903 // recopying of data, as would happen if we used a single resize.
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1904 // It should be noted that resize operation is also significantly
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1905 // slower than the do_cat_op function, so it makes sense to have
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1906 // an empty matrix and copy all data.
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1907 //
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1908 // We might also start with a empty octave_value using
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1909 // tmp = octave_value_typeinfo::lookup_type
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1910 // (args(1).type_name());
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1911 // and then directly resize. However, for some types there might
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1912 // be some additional setup needed, and so this should be avoided.
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1913
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1914 octave_value tmp = args (1);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1915 tmp = tmp.resize (dim_vector (0,0)).resize (dv);
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1916
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1917 if (error_state)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1918 return retval;
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1919
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1920 int dv_len = dv.length ();
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1921 Array<octave_idx_type> ra_idx (dv_len, 0);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1922
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1923 for (int j = 1; j < n_args; j++)
6401 f8cbc0871ed6 [project @ 2007-03-09 15:34:45 by dbateman] dbateman parents: 6399 diff changeset	1924 {
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1925 // Can't fast return here to skip empty matrices as something
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1926 // like cat(1,[],single([])) must return an empty matrix of
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1927 // the right type.
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1928 tmp = do_cat_op (tmp, args (j), ra_idx);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1929
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1930 if (error_state)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1931 return retval;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1932
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1933 dim_vector dv_tmp = args (j).dims ();
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1934
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1935 if (dim >= dv_len)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1936 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1937 if (j > 1)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1938 error ("%s: indexing error", fname.c_str ());
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1939 break;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1940 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1941 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1942 ra_idx (dim) += (dim < dv_tmp.length () ?
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1943 dv_tmp (dim) : 1);
6401 f8cbc0871ed6 [project @ 2007-03-09 15:34:45 by dbateman] dbateman parents: 6399 diff changeset	1944 }
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1945 retval = tmp;
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1946 }
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1947
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1948 if (! error_state)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1949 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1950 // Reshape, chopping trailing singleton dimensions
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1951 dv.chop_trailing_singletons ();
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1952 retval = retval.reshape (dv);
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1953 }
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1954 }
5533 667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1955 else
667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1956 error ("%s: invalid dimension argument", fname.c_str ());
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1957 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1958 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1959 print_usage ();
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1960
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1961 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1962 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1963
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1964 DEFUN (horzcat, args, ,
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1965 "-- texinfo --\n\
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1966 @deftypefn {Built-in Function} {} horzcat (@var{array1}, @var{array2}, @dots{}, @var{arrayN})\n\
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1967 Return the horizontal concatenation of N-d array objects, @var{array1},\n\
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1968 @var{array2}, @dots{}, @var{arrayN} along dimension 2.\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	1969 @seealso{cat, vertcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	1970 @end deftypefn")
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1971 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1972 octave_value_list args_tmp = args;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1973
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1974 int dim = 2;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1975
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1976 octave_value d (dim);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1977
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1978 args_tmp.prepend (d);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1979
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1980 return do_cat (args_tmp, "horzcat");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1981 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1982
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1983 DEFUN (vertcat, args, ,
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1984 "-- texinfo --\n\
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1985 @deftypefn {Built-in Function} {} vertcat (@var{array1}, @var{array2}, @dots{}, @var{arrayN})\n\
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1986 Return the vertical concatenation of N-d array objects, @var{array1},\n\
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1987 @var{array2}, @dots{}, @var{arrayN} along dimension 1.\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	1988 @seealso{cat, horzcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	1989 @end deftypefn")
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1990 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1991 octave_value_list args_tmp = args;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1992
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1993 int dim = 1;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1994
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1995 octave_value d (dim);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1996
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1997 args_tmp.prepend (d);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1998
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1999 return do_cat (args_tmp, "vertcat");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2000 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2001
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2002 DEFUN (cat, args, ,
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2003 "-- texinfo --\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2004 @deftypefn {Built-in Function} {} cat (@var{dim}, @var{array1}, @var{array2}, @dots{}, @var{arrayN})\n\
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2005 Return the concatenation of N-d array objects, @var{array1},\n\
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2006 @var{array2}, @dots{}, @var{arrayN} along dimension @var{dim}.\n\
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2007 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2008 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2009 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2010 A = ones (2, 2);\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2011 B = zeros (2, 2);\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2012 cat (2, A, B)\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2013 @result{} ans =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2014 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2015 1 1 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2016 1 1 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2017 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2018 @end example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2019 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2020 Alternatively, we can concatenate @var{A} and @var{B} along the\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2021 second dimension the following way:\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2022 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2023 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2024 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2025 [A, B].\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2026 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2027 @end example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2028 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2029 @var{dim} can be larger than the dimensions of the N-d array objects\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2030 and the result will thus have @var{dim} dimensions as the\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2031 following example shows:\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2032 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2033 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2034 cat (4, ones(2, 2), zeros (2, 2))\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2035 @result{} ans =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2036 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2037 ans(:,:,1,1) =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2038 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2039 1 1\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2040 1 1\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2041 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2042 ans(:,:,1,2) =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2043 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2044 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2045 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2046 @end example\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2047 @seealso{horzcat, vertcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2048 @end deftypefn")
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2049 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	2050 return do_cat (args, "cat");
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2051 }
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2052
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2053 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2054
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2055 %!function ret = testcat (t1, t2, tr, cmplx)
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2056 %! assert (cat (1, cast ([], t1), cast([], t2)), cast ([], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2057 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2058 %! assert (cat (1, cast (1, t1), cast (2, t2)), cast ([1; 2], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2059 %! assert (cat (1, cast (1, t1), cast ([2; 3], t2)), cast ([1; 2; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2060 %! assert (cat (1, cast ([1; 2], t1), cast (3, t2)), cast ([1; 2; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2061 %! assert (cat (1, cast ([1; 2], t1), cast ([3; 4], t2)), cast ([1; 2; 3; 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2062 %! assert (cat (2, cast (1, t1), cast (2, t2)), cast ([1, 2], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2063 %! assert (cat (2, cast (1, t1), cast ([2, 3], t2)), cast ([1, 2, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2064 %! assert (cat (2, cast ([1, 2], t1), cast (3, t2)), cast ([1, 2, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2065 %! assert (cat (2, cast ([1, 2], t1), cast ([3, 4], t2)), cast ([1, 2, 3, 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2066 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2067 %! assert ([cast(1, t1); cast(2, t2)], cast ([1; 2], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2068 %! assert ([cast(1, t1); cast([2; 3], t2)], cast ([1; 2; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2069 %! assert ([cast([1; 2], t1); cast(3, t2)], cast ([1; 2; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2070 %! assert ([cast([1; 2], t1); cast([3; 4], t2)], cast ([1; 2; 3; 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2071 %! assert ([cast(1, t1), cast(2, t2)], cast ([1, 2], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2072 %! assert ([cast(1, t1), cast([2, 3], t2)], cast ([1, 2, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2073 %! assert ([cast([1, 2], t1), cast(3, t2)], cast ([1, 2, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2074 %! assert ([cast([1, 2], t1), cast([3, 4], t2)], cast ([1, 2, 3, 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2075 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2076 %! if (nargin == 3 \|\| cmplx)
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2077 %! assert (cat (1, cast (1i, t1), cast (2, t2)), cast ([1i; 2], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2078 %! assert (cat (1, cast (1i, t1), cast ([2; 3], t2)), cast ([1i; 2; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2079 %! assert (cat (1, cast ([1i; 2], t1), cast (3, t2)), cast ([1i; 2; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2080 %! assert (cat (1, cast ([1i; 2], t1), cast ([3; 4], t2)), cast ([1i; 2; 3; 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2081 %! assert (cat (2, cast (1i, t1), cast (2, t2)), cast ([1i, 2], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2082 %! assert (cat (2, cast (1i, t1), cast ([2, 3], t2)), cast ([1i, 2, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2083 %! assert (cat (2, cast ([1i, 2], t1), cast (3, t2)), cast ([1i, 2, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2084 %! assert (cat (2, cast ([1i, 2], t1), cast ([3, 4], t2)), cast ([1i, 2, 3, 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2085 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2086 %! assert ([cast(1i, t1); cast(2, t2)], cast ([1i; 2], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2087 %! assert ([cast(1i, t1); cast([2; 3], t2)], cast ([1i; 2; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2088 %! assert ([cast([1i; 2], t1); cast(3, t2)], cast ([1i; 2; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2089 %! assert ([cast([1i; 2], t1); cast([3; 4], t2)], cast ([1i; 2; 3; 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2090 %! assert ([cast(1i, t1), cast(2, t2)], cast ([1i, 2], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2091 %! assert ([cast(1i, t1), cast([2, 3], t2)], cast ([1i, 2, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2092 %! assert ([cast([1i, 2], t1), cast(3, t2)], cast ([1i, 2, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2093 %! assert ([cast([1i, 2], t1), cast([3, 4], t2)], cast ([1i, 2, 3, 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2094 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2095 %! assert (cat (1, cast (1, t1), cast (2i, t2)), cast ([1; 2i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2096 %! assert (cat (1, cast (1, t1), cast ([2i; 3], t2)), cast ([1; 2i; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2097 %! assert (cat (1, cast ([1; 2], t1), cast (3i, t2)), cast ([1; 2; 3i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2098 %! assert (cat (1, cast ([1; 2], t1), cast ([3i; 4], t2)), cast ([1; 2; 3i; 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2099 %! assert (cat (2, cast (1, t1), cast (2i, t2)), cast ([1, 2i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2100 %! assert (cat (2, cast (1, t1), cast ([2i, 3], t2)), cast ([1, 2i, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2101 %! assert (cat (2, cast ([1, 2], t1), cast (3i, t2)), cast ([1, 2, 3i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2102 %! assert (cat (2, cast ([1, 2], t1), cast ([3i, 4], t2)), cast ([1, 2, 3i, 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2103 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2104 %! assert ([cast(1, t1); cast(2i, t2)], cast ([1; 2i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2105 %! assert ([cast(1, t1); cast([2i; 3], t2)], cast ([1; 2i; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2106 %! assert ([cast([1; 2], t1); cast(3i, t2)], cast ([1; 2; 3i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2107 %! assert ([cast([1; 2], t1); cast([3i; 4], t2)], cast ([1; 2; 3i; 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2108 %! assert ([cast(1, t1), cast(2i, t2)], cast ([1, 2i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2109 %! assert ([cast(1, t1), cast([2i, 3], t2)], cast ([1, 2i, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2110 %! assert ([cast([1, 2], t1), cast(3i, t2)], cast ([1, 2, 3i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2111 %! assert ([cast([1, 2], t1), cast([3i, 4], t2)], cast ([1, 2, 3i, 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2112 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2113 %! assert (cat (1, cast (1i, t1), cast (2i, t2)), cast ([1i; 2i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2114 %! assert (cat (1, cast (1i, t1), cast ([2i; 3], t2)), cast ([1i; 2i; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2115 %! assert (cat (1, cast ([1i; 2], t1), cast (3i, t2)), cast ([1i; 2; 3i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2116 %! assert (cat (1, cast ([1i; 2], t1), cast ([3i; 4], t2)), cast ([1i; 2; 3i; 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2117 %! assert (cat (2, cast (1i, t1), cast (2i, t2)), cast ([1i, 2i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2118 %! assert (cat (2, cast (1i, t1), cast ([2i, 3], t2)), cast ([1i, 2i, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2119 %! assert (cat (2, cast ([1i, 2], t1), cast (3i, t2)), cast ([1i, 2, 3i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2120 %! assert (cat (2, cast ([1i, 2], t1), cast ([3i, 4], t2)), cast ([1i, 2, 3i, 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2121 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2122 %! assert ([cast(1i, t1); cast(2i, t2)], cast ([1i; 2i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2123 %! assert ([cast(1i, t1); cast([2i; 3], t2)], cast ([1i; 2i; 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2124 %! assert ([cast([1i; 2], t1); cast(3i, t2)], cast ([1i; 2; 3i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2125 %! assert ([cast([1i; 2], t1); cast([3i; 4], t2)], cast ([1i; 2; 3i; 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2126 %! assert ([cast(1i, t1), cast(2i, t2)], cast ([1i, 2i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2127 %! assert ([cast(1i, t1), cast([2i, 3], t2)], cast ([1i, 2i, 3], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2128 %! assert ([cast([1i, 2], t1), cast(3i, t2)], cast ([1i, 2, 3i], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2129 %! assert ([cast([1i, 2], t1), cast([3i, 4], t2)], cast ([1i, 2, 3i, 4], tr));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2130 %! endif
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2131 %! ret = true;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2132
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2133 %!assert (testcat('double', 'double', 'double'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2134 %!assert (testcat('single', 'double', 'single'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2135 %!assert (testcat('double', 'single', 'single'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2136 %!assert (testcat('single', 'single', 'single'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2137
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2138 %!assert (testcat('double', 'int8', 'int8', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2139 %!assert (testcat('int8', 'double', 'int8', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2140 %!assert (testcat('single', 'int8', 'int8', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2141 %!assert (testcat('int8', 'single', 'int8', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2142 %!assert (testcat('int8', 'int8', 'int8', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2143 %!assert (testcat('double', 'int16', 'int16', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2144 %!assert (testcat('int16', 'double', 'int16', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2145 %!assert (testcat('single', 'int16', 'int16', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2146 %!assert (testcat('int16', 'single', 'int16', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2147 %!assert (testcat('int16', 'int16', 'int16', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2148 %!assert (testcat('double', 'int32', 'int32', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2149 %!assert (testcat('int32', 'double', 'int32', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2150 %!assert (testcat('single', 'int32', 'int32', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2151 %!assert (testcat('int32', 'single', 'int32', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2152 %!assert (testcat('int32', 'int32', 'int32', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2153 %!assert (testcat('double', 'int64', 'int64', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2154 %!assert (testcat('int64', 'double', 'int64', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2155 %!assert (testcat('single', 'int64', 'int64', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2156 %!assert (testcat('int64', 'single', 'int64', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2157 %!assert (testcat('int64', 'int64', 'int64', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2158
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2159 %!assert (testcat('double', 'uint8', 'uint8', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2160 %!assert (testcat('uint8', 'double', 'uint8', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2161 %!assert (testcat('single', 'uint8', 'uint8', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2162 %!assert (testcat('uint8', 'single', 'uint8', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2163 %!assert (testcat('uint8', 'uint8', 'uint8', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2164 %!assert (testcat('double', 'uint16', 'uint16', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2165 %!assert (testcat('uint16', 'double', 'uint16', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2166 %!assert (testcat('single', 'uint16', 'uint16', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2167 %!assert (testcat('uint16', 'single', 'uint16', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2168 %!assert (testcat('uint16', 'uint16', 'uint16', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2169 %!assert (testcat('double', 'uint32', 'uint32', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2170 %!assert (testcat('uint32', 'double', 'uint32', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2171 %!assert (testcat('single', 'uint32', 'uint32', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2172 %!assert (testcat('uint32', 'single', 'uint32', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2173 %!assert (testcat('uint32', 'uint32', 'uint32', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2174 %!assert (testcat('double', 'uint64', 'uint64', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2175 %!assert (testcat('uint64', 'double', 'uint64', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2176 %!assert (testcat('single', 'uint64', 'uint64', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2177 %!assert (testcat('uint64', 'single', 'uint64', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2178 %!assert (testcat('uint64', 'uint64', 'uint64', false));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2179
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2180 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2181
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2182 static octave_value
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2183 do_permute (const octave_value_list& args, bool inv)
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2184 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2185 octave_value retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2186
5148 9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2187 if (args.length () == 2 && args(1).length () >= args(1).ndims ())
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2188 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2189 Array<int> vec = args(1).int_vector_value ();
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2190
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	2191 // FIXME -- maybe we should create an idx_vector object
5148 9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2192 // here and pass that to permute?
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2193
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2194 int n = vec.length ();
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2195
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2196 for (int i = 0; i < n; i++)
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2197 vec(i)--;
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2198
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2199 octave_value ret = args(0).permute (vec, inv);
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2200
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2201 if (! error_state)
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2202 retval = ret;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2203 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2204 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2205 print_usage ();
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2206
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2207 return retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2208 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2209
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2210 DEFUN (permute, args, ,
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2211 "-- texinfo --\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2212 @deftypefn {Built-in Function} {} permute (@var{a}, @var{perm})\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2213 Return the generalized transpose for an N-d array object @var{a}.\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2214 The permutation vector @var{perm} must contain the elements\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2215 @code{1:ndims(a)} (in any order, but each element must appear just once).\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2216 @seealso{ipermute}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2217 @end deftypefn")
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2218 {
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2219 return do_permute (args, false);
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2220 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2221
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2222 DEFUN (ipermute, args, ,
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2223 "-- texinfo --\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2224 @deftypefn {Built-in Function} {} ipermute (@var{a}, @var{iperm})\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2225 The inverse of the @code{permute} function. The expression\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2226 \n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2227 @example\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2228 ipermute (permute (a, perm), perm)\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2229 @end example\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2230 returns the original array @var{a}.\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2231 @seealso{permute}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2232 @end deftypefn")
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2233 {
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2234 return do_permute (args, true);
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2235 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2236
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2237 DEFUN (length, args, ,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2238 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2239 @deftypefn {Built-in Function} {} length (@var{a})\n\
4176 b8ec44432831 [project @ 2002-11-13 02:49:14 by jwe] jwe parents: 4153 diff changeset	2240 Return the `length' of the object @var{a}. For matrix objects, the\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2241 length is the number of rows or columns, whichever is greater (this\n\
6556 8810bbf321ce [project @ 2007-04-20 18:39:40 by jwe] jwe parents: 6518 diff changeset	2242 odd definition is used for compatibility with @sc{Matlab}).\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2243 @end deftypefn")
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2244 {
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2245 octave_value retval;
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2246
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2247 if (args.length () == 1)
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2248 {
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2249 int len = args(0).length ();
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2250
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2251 if (! error_state)
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	2252 retval = len;
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2253 }
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2254 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2255 print_usage ();
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2256
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2257 return retval;
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2258 }
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2259
4554 78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2260 DEFUN (ndims, args, ,
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2261 "-- texinfo --\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2262 @deftypefn {Built-in Function} {} ndims (@var{a})\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2263 Returns the number of dimensions of array @var{a}.\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2264 For any array, the result will always be larger than or equal to 2.\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2265 Trailing singleton dimensions are not counted.\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2266 @end deftypefn")
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2267 {
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2268 octave_value retval;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2269
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2270 if (args.length () == 1)
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2271 {
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2272 int n_dims = args(0).ndims ();
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2273
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2274 if (! error_state)
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2275 retval = n_dims;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2276 }
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2277 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2278 print_usage ();
4554 78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2279
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2280 return retval;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2281 }
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2282
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2283 DEFUN (numel, args, ,
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2284 "-- texinfo --\n\
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2285 @deftypefn {Built-in Function} {} numel (@var{a})\n\
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2286 Returns the number of elements in the object @var{a}.\n\
5724 82247c2a7520 [project @ 2006-03-30 21:34:52 by jwe] jwe parents: 5714 diff changeset	2287 @seealso{size}\n\
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2288 @end deftypefn")
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2289 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2290 octave_value retval;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2291
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2292 if (args.length () == 1)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2293 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2294 int numel = args(0).numel ();
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2295
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2296 if (! error_state)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2297 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2298 if (numel < 0)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2299 numel = 0;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2300
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2301 retval = numel;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2302 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2303 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2304 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2305 print_usage ();
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2306
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2307 return retval;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2308 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2309
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2310 DEFUN (size, args, nargout,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2311 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2312 @deftypefn {Built-in Function} {} size (@var{a}, @var{n})\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2313 Return the number rows and columns of @var{a}.\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2314 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2315 With one input argument and one output argument, the result is returned\n\
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2316 in a row vector. If there are multiple output arguments, the number of\n\
e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2317 rows is assigned to the first, and the number of columns to the second,\n\
e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2318 etc. For example,\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2319 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2320 @example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2321 @group\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2322 size ([1, 2; 3, 4; 5, 6])\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2323 @result{} [ 3, 2 ]\n\
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2324 \n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2325 [nr, nc] = size ([1, 2; 3, 4; 5, 6])\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2326 @result{} nr = 3\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2327 @result{} nc = 2\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2328 @end group\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2329 @end example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2330 \n\
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2331 If given a second argument, @code{size} will return the size of the\n\
e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2332 corresponding dimension. For example\n\
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2333 \n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2334 @example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2335 size ([1, 2; 3, 4; 5, 6], 2)\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2336 @result{} 2\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2337 @end example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2338 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2339 @noindent\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2340 returns the number of columns in the given matrix.\n\
5724 82247c2a7520 [project @ 2006-03-30 21:34:52 by jwe] jwe parents: 5714 diff changeset	2341 @seealso{numel}\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2342 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2343 {
2086 bfb775fb6fe8 [project @ 1996-04-25 05:55:19 by jwe] jwe parents: 1996 diff changeset	2344 octave_value_list retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2345
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2346 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2347
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2348 if (nargin == 1)
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2349 {
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2350 dim_vector dimensions = args(0).dims ();
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2351
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2352 int ndims = dimensions.length ();
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2353
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2354 Matrix m (1, ndims);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2355
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2356 if (nargout > 1)
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2357 {
5991 265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2358 for (int i = nargout-1; i >= ndims; i--)
265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2359 retval(i) = 1;
265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2360
6197 c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2361 if (ndims > nargout)
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2362 {
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2363 octave_idx_type d = 1;
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2364
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2365 while (ndims >= nargout)
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2366 d *= dimensions(--ndims);
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2367
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2368 retval(ndims) = d;
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2369 }
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2370
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2371 while (ndims--)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2372 retval(ndims) = dimensions(ndims);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2373 }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2374 else
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2375 {
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2376 for (int i = 0; i < ndims; i++)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2377 m(0, i) = dimensions(i);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2378
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2379 retval(0) = m;
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2380 }
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2381 }
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2382 else if (nargin == 2 && nargout < 2)
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2383 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	2384 octave_idx_type nd = args(1).int_value (true);
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2385
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2386 if (error_state)
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2387 error ("size: expecting scalar as second argument");
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2388 else
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2389 {
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2390 dim_vector dv = args(0).dims ();
e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2391
4911 14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2392 if (nd > 0)
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2393 {
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2394 if (nd <= dv.length ())
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2395 retval(0) = dv(nd-1);
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2396 else
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2397 retval(0) = 1;
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2398 }
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2399 else
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2400 error ("size: requested dimension (= %d) out of range", nd);
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2401 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2402 }
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2403 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2404 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2405
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2406 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2407 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2408
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2409 DEFUN (size_equal, args, ,
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2410 "-- texinfo --\n\
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2411 @deftypefn {Built-in Function} {} size_equal (@var{a}, @var{b}, @dots{})\n\
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2412 Return true if the dimensions of all arguments agree.\n\
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2413 Trailing singleton dimensions are ignored.\n\
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2414 @seealso{size, numel}\n\
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2415 @end deftypefn")
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2416 {
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2417 octave_value retval;
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2418
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2419 int nargin = args.length ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2420
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2421 if (nargin >= 2)
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2422 {
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2423 retval = true;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2424
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2425 dim_vector a_dims = args(0).dims ();
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2426 a_dims.chop_trailing_singletons ();
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2427
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2428 for (int i = 1; i < nargin; ++i)
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2429 {
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2430 dim_vector b_dims = args(i).dims ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2431 b_dims.chop_trailing_singletons ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2432
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2433 if (a_dims != b_dims)
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2434 {
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2435 retval = false;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2436 break;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2437 }
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2438 }
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2439 }
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2440 else
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2441 print_usage ();
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2442
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2443 return retval;
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2444 }
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2445
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2446 DEFUN (nnz, args, ,
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2447 "-- texinfo --\n\
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2448 @deftypefn {Built-in Function} {@var{scalar} =} nnz (@var{a})\n\
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2449 Returns the number of non zero elements in @var{a}.\n\
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2450 @seealso{sparse}\n\
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2451 @end deftypefn")
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2452 {
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2453 octave_value retval;
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2454
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2455 if (args.length () == 1)
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2456 retval = args(0).nnz ();
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2457 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2458 print_usage ();
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2459
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2460 return retval;
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2461 }
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2462
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2463 DEFUN (nzmax, args, ,
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2464 "-- texinfo --\n\
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2465 @deftypefn {Built-in Function} {@var{scalar} =} nzmax (@var{SM})\n\
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2466 Return the amount of storage allocated to the sparse matrix @var{SM}.\n\
7001 8b0cfeb06365 [project @ 2007-10-10 18:02:59 by jwe] jwe parents: 6999 diff changeset	2467 Note that Octave tends to crop unused memory at the first opportunity\n\
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2468 for sparse objects. There are some cases of user created sparse objects\n\
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2469 where the value returned by @dfn{nzmaz} will not be the same as @dfn{nnz},\n\
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2470 but in general they will give the same result.\n\
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2471 @seealso{sparse, spalloc}\n\
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2472 @end deftypefn")
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2473 {
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2474 octave_value retval;
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2475
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2476 if (args.length() == 1)
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2477 retval = args(0).nzmax ();
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2478 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2479 print_usage ();
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2480
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2481 return retval;
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2482 }
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2483
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2484 DEFUN (rows, args, ,
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2485 "-- texinfo --\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2486 @deftypefn {Built-in Function} {} rows (@var{a})\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2487 Return the number of rows of @var{a}.\n\
5724 82247c2a7520 [project @ 2006-03-30 21:34:52 by jwe] jwe parents: 5714 diff changeset	2488 @seealso{size, numel, columns, length, isscalar, isvector, ismatrix}\n\
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2489 @end deftypefn")
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2490 {
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2491 octave_value retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2492
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2493 if (args.length () == 1)
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2494 retval = args(0).rows ();
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2495 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2496 print_usage ();
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2497
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2498 return retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2499 }
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2500
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2501 DEFUN (columns, args, ,
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2502 "-- texinfo --\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2503 @deftypefn {Built-in Function} {} columns (@var{a})\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2504 Return the number of columns of @var{a}.\n\
8286 6f2d95255911 fix @seealso references to point to existing anchors Thorsten Meyer <thorsten.meyier@gmx.de> parents: 8129 diff changeset	2505 @seealso{size, numel, rows, length, isscalar, isvector, ismatrix}\n\
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2506 @end deftypefn")
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2507 {
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2508 octave_value retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2509
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2510 if (args.length () == 1)
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2511 retval = args(0).columns ();
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2512 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2513 print_usage ();
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2514
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2515 return retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2516 }
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2517
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2518 DEFUN (sum, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2519 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2520 @deftypefn {Built-in Function} {} sum (@var{x}, @var{dim})\n\
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2521 @deftypefnx {Built-in Function} {} sum (@dots{}, 'native')\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2522 Sum of elements along dimension @var{dim}. If @var{dim} is\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2523 omitted, it defaults to 1 (column-wise sum).\n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2524 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2525 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2526 return the sum of the elements.\n\
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2527 \n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2528 If the optional argument 'native' is given, then the sum is performed\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2529 in the same type as the original argument, rather than in the default\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2530 double type. For example\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2531 \n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2532 @example\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2533 sum ([true, true])\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2534 @result{} 2\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2535 sum ([true, true], 'native')\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2536 @result{} true\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2537 @end example\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2538 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2539 {
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2540 NATIVE_REDUCTION (sum);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2541 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2542
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2543 /*
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2544
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2545 %!assert (sum([true,true]), 2)
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2546 %!assert (sum([true,true],'native'), true)
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2547 %!assert (sum(int8([127,10,-20])), 117);
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2548 %!assert (sum(int8([127,10,-20]),'native'), int8(107));
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2549
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2550 %!assert(sum ([1, 2, 3]), 6)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2551 %!assert(sum ([-1; -2; -3]), -6);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2552 %!assert(sum ([i, 2+i, -3+2i, 4]), 3+4i);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2553 %!assert(sum ([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i]), [2+2i, 4+4i, 6+6i]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2554
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2555 %!assert(sum (single([1, 2, 3])), single(6))
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2556 %!assert(sum (single([-1; -2; -3])), single(-6));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2557 %!assert(sum (single([i, 2+i, -3+2i, 4])), single(3+4i));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2558 %!assert(sum (single([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i])), single([2+2i, 4+4i, 6+6i]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2559
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2560 %!error <Invalid call to sum.*> sum ();
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2561
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2562 %!assert (sum ([1, 2; 3, 4], 1), [4, 6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2563 %!assert (sum ([1, 2; 3, 4], 2), [3; 7]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2564 %!assert (sum (zeros (1, 0)), 0);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2565 %!assert (sum (zeros (1, 0), 1), zeros(1, 0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2566 %!assert (sum (zeros (1, 0), 2), 0);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2567 %!assert (sum (zeros (0, 1)), 0);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2568 %!assert (sum (zeros (0, 1), 1), 0);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2569 %!assert (sum (zeros (0, 1), 2), zeros(0, 1));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2570 %!assert (sum (zeros (2, 0)), zeros(1, 0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2571 %!assert (sum (zeros (2, 0), 1), zeros(1, 0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2572 %!assert (sum (zeros (2, 0), 2), [0; 0]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2573 %!assert (sum (zeros (0, 2)), [0, 0]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2574 %!assert (sum (zeros (0, 2), 1), [0, 0]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2575 %!assert (sum (zeros (0, 2), 2), zeros(0, 1));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2576 %!assert (sum (zeros (2, 2, 0, 3)), zeros(1, 2, 0, 3));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2577 %!assert (sum (zeros (2, 2, 0, 3), 2), zeros(2, 1, 0, 3));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2578 %!assert (sum (zeros (2, 2, 0, 3), 3), zeros(2, 2, 1, 3));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2579 %!assert (sum (zeros (2, 2, 0, 3), 4), zeros(2, 2, 0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2580 %!assert (sum (zeros (2, 2, 0, 3), 7), zeros(2, 2, 0, 3));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2581
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2582 %!assert (sum (single([1, 2; 3, 4]), 1), single([4, 6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2583 %!assert (sum (single([1, 2; 3, 4]), 2), single([3; 7]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2584 %!assert (sum (zeros (1, 0, 'single')), single(0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2585 %!assert (sum (zeros (1, 0, 'single'), 1), zeros(1, 0, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2586 %!assert (sum (zeros (1, 0, 'single'), 2), single(0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2587 %!assert (sum (zeros (0, 1, 'single')), single(0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2588 %!assert (sum (zeros (0, 1, 'single'), 1), single(0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2589 %!assert (sum (zeros (0, 1, 'single'), 2), zeros(0, 1, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2590 %!assert (sum (zeros (2, 0, 'single')), zeros(1, 0, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2591 %!assert (sum (zeros (2, 0, 'single'), 1), zeros(1, 0, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2592 %!assert (sum (zeros (2, 0, 'single'), 2), single([0; 0]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2593 %!assert (sum (zeros (0, 2, 'single')), single([0, 0]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2594 %!assert (sum (zeros (0, 2, 'single'), 1), single([0, 0]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2595 %!assert (sum (zeros (0, 2, 'single'), 2), zeros(0, 1, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2596 %!assert (sum (zeros (2, 2, 0, 3, 'single')), zeros(1, 2, 0, 3, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2597 %!assert (sum (zeros (2, 2, 0, 3, 'single'), 2), zeros(2, 1, 0, 3, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2598 %!assert (sum (zeros (2, 2, 0, 3, 'single'), 3), zeros(2, 2, 1, 3, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2599 %!assert (sum (zeros (2, 2, 0, 3, 'single'), 4), zeros(2, 2, 0, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2600 %!assert (sum (zeros (2, 2, 0, 3, 'single'), 7), zeros(2, 2, 0, 3, 'single'));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2601
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2602 */
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2603
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2604 DEFUN (sumsq, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2605 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2606 @deftypefn {Built-in Function} {} sumsq (@var{x}, @var{dim})\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2607 Sum of squares of elements along dimension @var{dim}. If @var{dim}\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2608 is omitted, it defaults to 1 (column-wise sum of squares).\n\
3095 528f4270e904 [project @ 1997-11-14 03:58:45 by jwe] jwe parents: 3014 diff changeset	2609 \n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2610 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2611 return the sum of squares of the elements.\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2612 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2613 This function is conceptually equivalent to computing\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2614 @example\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2615 sum (x .* conj (x), dim)\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2616 @end example\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2617 but it uses less memory and avoids calling conj if @var{x} is real.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2618 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2619 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2620 DATA_REDUCTION (sumsq);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2621 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2622
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2623 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2624
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2625 %!assert(sumsq ([1, 2, 3]), 14)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2626 %!assert(sumsq ([-1; -2; 4i]), 21);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2627 %!assert(sumsq ([1, 2, 3; 2, 3, 4; 4i, 6i, 2]), [21, 49, 29]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2628
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2629 %!assert(sumsq (single([1, 2, 3])), single(14))
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2630 %!assert(sumsq (single([-1; -2; 4i])), single(21));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2631 %!assert(sumsq (single([1, 2, 3; 2, 3, 4; 4i, 6i, 2])), single([21, 49, 29]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2632
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2633 %!error <Invalid call to sumsq.*> sumsq ();
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2634
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2635 %!assert (sumsq ([1, 2; 3, 4], 1), [10, 20]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2636 %!assert (sumsq ([1, 2; 3, 4], 2), [5; 25]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2637
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2638 %!assert (sumsq (single([1, 2; 3, 4]), 1), single([10, 20]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2639 %!assert (sumsq (single([1, 2; 3, 4]), 2), single([5; 25]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2640
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2641 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2642
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2643 DEFUN (islogical, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2644 "-- texinfo --\n\
7144 30c0533e39ae [project @ 2007-11-09 17:37:24 by jwe] jwe parents: 7112 diff changeset	2645 @deftypefn {Built-in Function} {} islogical (@var{x})\n\
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2646 Return true if @var{x} is a logical object.\n\
3439 3234a698073a [project @ 2000-01-14 09:51:14 by jwe] jwe parents: 3428 diff changeset	2647 @end deftypefn")
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2648 {
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2649 octave_value retval;
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2650
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2651 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2652 retval = args(0).is_bool_type ();
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2653 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2654 print_usage ();
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2655
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2656 return retval;
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2657 }
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2658
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2659 DEFALIAS (isbool, islogical);
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2660
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2661 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2662
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2663 %!assert (islogical(true), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2664 %!assert (islogical(false), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2665 %!assert (islogical([true, false]), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2666 %!assert (islogical(1), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2667 %!assert (islogical(1i), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2668 %!assert (islogical([1,1]), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2669 %!assert (islogical(single(1)), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2670 %!assert (islogical(single(1i)), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2671 %!assert (islogical(single([1,1])), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2672
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2673 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2674
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2675 DEFUN (isinteger, args, ,
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2676 "-- texinfo --\n\
6230 06bee64edc08 [project @ 2007-01-08 16:59:35 by jwe] jwe parents: 6223 diff changeset	2677 @deftypefn {Built-in Function} {} isinteger (@var{x})\n\
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2678 Return true if @var{x} is an integer object (int8, uint8, int16, etc.).\n\
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2679 Note that @code{isinteger (14)} is false because numeric constants in\n\
8429 f34ab2b433e8 One word missing from int8 help string. Francesco PotortÃ¬ <pot@gnu.org> parents: 8366 diff changeset	2680 Octave are double precision floating point values.\n\
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2681 @seealso{isreal, isnumeric, class, isa}\n\
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2682 @end deftypefn")
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2683 {
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2684 octave_value retval;
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2685
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2686 if (args.length () == 1)
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2687 retval = args(0).is_integer_type ();
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2688 else
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2689 print_usage ();
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2690
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2691 return retval;
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2692 }
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2693
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	2694 DEFUN (iscomplex, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2695 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	2696 @deftypefn {Built-in Function} {} iscomplex (@var{x})\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2697 Return true if @var{x} is a complex-valued numeric object.\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2698 @end deftypefn")
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2699 {
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2700 octave_value retval;
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2701
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2702 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2703 retval = args(0).is_complex_type ();
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2704 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2705 print_usage ();
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2706
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2707 return retval;
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2708 }
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2709
7576 7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2710 DEFUN (isfloat, args, ,
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2711 "-- texinfo --\n\
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2712 @deftypefn {Built-in Function} {} isfloat (@var{x})\n\
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2713 Return true if @var{x} is a floating-point numeric object.\n\
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2714 @end deftypefn")
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2715 {
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2716 octave_value retval;
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2717
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2718 if (args.length () == 1)
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2719 retval = args(0).is_float_type ();
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2720 else
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2721 print_usage ();
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2722
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2723 return retval;
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2724 }
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2725
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	2726 // FIXME -- perhaps this should be implemented with an
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2727 // octave_value member function?
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2728
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2729 DEFUN (complex, args, ,
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2730 "-- texinfo --\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2731 @deftypefn {Built-in Function} {} complex (@var{val})\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2732 @deftypefnx {Built-in Function} {} complex (@var{re}, @var{im})\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2733 Convert @var{x} to a complex value.\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2734 @end deftypefn")
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2735 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2736 octave_value retval;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2737
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2738 int nargin = args.length ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2739
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2740 if (nargin == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2741 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2742 octave_value arg = args(0);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2743
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2744 if (arg.is_complex_type ())
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2745 retval = arg;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2746 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2747 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2748 if (arg.is_sparse_type ())
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2749 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2750 SparseComplexMatrix val = arg.sparse_complex_matrix_value ();
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2751
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2752 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2753 retval = octave_value (new octave_sparse_complex_matrix (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2754 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2755 else if (arg.is_single_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2756 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2757 if (arg.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2758 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2759 FloatComplex val = arg.float_complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2760
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2761 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2762 retval = octave_value (new octave_float_complex (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2763 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2764 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2765 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2766 FloatComplexNDArray val = arg.float_complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2767
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2768 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2769 retval = octave_value (new octave_float_complex_matrix (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2770 }
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2771 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2772 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2773 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2774 if (arg.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2775 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2776 Complex val = arg.complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2777
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2778 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2779 retval = octave_value (new octave_complex (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2780 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2781 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2782 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2783 ComplexNDArray val = arg.complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2784
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2785 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2786 retval = octave_value (new octave_complex_matrix (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2787 }
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2788 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2789
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2790 if (error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2791 error ("complex: invalid conversion");
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2792 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2793 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2794 else if (nargin == 2)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2795 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2796 octave_value re = args(0);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2797 octave_value im = args(1);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2798
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2799 if (re.is_sparse_type () && im.is_sparse_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2800 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2801 const SparseMatrix re_val = re.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2802 const SparseMatrix im_val = im.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2803
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2804 if (!error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2805 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2806 if (re.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2807 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2808 SparseComplexMatrix result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2809 if (re_val.nnz () == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2810 result = Complex(0, 1) * SparseComplexMatrix (im_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2811 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2812 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2813 result = SparseComplexMatrix (im_val.dims (), re_val (0));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2814 octave_idx_type nr = im_val.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2815 octave_idx_type nc = im_val.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2816
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2817 for (octave_idx_type j = 0; j < nc; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2818 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2819 octave_idx_type off = j * nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2820 for (octave_idx_type i = im_val.cidx(j);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2821 i < im_val.cidx(j + 1); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2822 result.data (im_val.ridx(i) + off) =
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2823 result.data (im_val.ridx(i) + off) +
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2824 Complex (0, im_val.data (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2825 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2826 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2827 retval = octave_value (new octave_sparse_complex_matrix (result));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2828 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2829 else if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2830 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2831 SparseComplexMatrix result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2832 if (im_val.nnz () == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2833 result = SparseComplexMatrix (re_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2834 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2835 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2836 result = SparseComplexMatrix (re_val.rows(), re_val.cols(), Complex(0, im_val (0)));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2837 octave_idx_type nr = re_val.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2838 octave_idx_type nc = re_val.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2839
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2840 for (octave_idx_type j = 0; j < nc; j++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2841 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2842 octave_idx_type off = j * nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2843 for (octave_idx_type i = re_val.cidx(j);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2844 i < re_val.cidx(j + 1); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2845 result.data (re_val.ridx(i) + off) =
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2846 result.data (re_val.ridx(i) + off) +
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2847 re_val.data (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2848 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2849 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2850 retval = octave_value (new octave_sparse_complex_matrix (result));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2851 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2852 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2853 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2854 if (re_val.dims () == im_val.dims ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2855 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2856 SparseComplexMatrix result = SparseComplexMatrix(re_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2857 + Complex(0, 1) * SparseComplexMatrix (im_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2858 retval = octave_value (new octave_sparse_complex_matrix (result));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2859 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2860 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2861 error ("complex: dimension mismatch");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2862 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2863 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2864 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2865 else if (re.is_single_type () \|\| im.is_single_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2866 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2867 if (re.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2868 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2869 float re_val = re.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2870
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2871 if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2872 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2873 float im_val = im.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2874
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2875 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2876 retval = octave_value (new octave_float_complex (FloatComplex (re_val, im_val)));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2877 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2878 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2879 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2880 const FloatNDArray im_val = im.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2881
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2882 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2883 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2884 FloatComplexNDArray result (im_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2885
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2886 for (octave_idx_type i = 0; i < im_val.numel (); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2887 result.xelem (i) = FloatComplex (re_val, im_val(i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2888
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2889 retval = octave_value (new octave_float_complex_matrix (result));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2890 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2891 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2892 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2893 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2894 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2895 const FloatNDArray re_val = re.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2896
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2897 if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2898 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2899 float im_val = im.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2900
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2901 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2902 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2903 FloatComplexNDArray result (re_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2904
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2905 for (octave_idx_type i = 0; i < re_val.numel (); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2906 result.xelem (i) = FloatComplex (re_val(i), im_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2907
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2908 retval = octave_value (new octave_float_complex_matrix (result));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2909 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2910 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2911 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2912 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2913 const FloatNDArray im_val = im.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2914
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2915 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2916 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2917 if (re_val.dims () == im_val.dims ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2918 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2919 FloatComplexNDArray result (re_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2920
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2921 for (octave_idx_type i = 0; i < re_val.numel (); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2922 result.xelem (i) = FloatComplex (re_val(i), im_val(i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2923
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2924 retval = octave_value (new octave_float_complex_matrix (result));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2925 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2926 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2927 error ("complex: dimension mismatch");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2928 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2929 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2930 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2931 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2932 else if (re.numel () == 1)
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2933 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2934 double re_val = re.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2935
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2936 if (im.numel () == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2937 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2938 double im_val = im.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2939
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2940 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2941 retval = octave_value (new octave_complex (Complex (re_val, im_val)));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2942 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2943 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2944 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2945 const NDArray im_val = im.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2946
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2947 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2948 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2949 ComplexNDArray result (im_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2950
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2951 for (octave_idx_type i = 0; i < im_val.numel (); i++)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2952 result.xelem (i) = Complex (re_val, im_val(i));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2953
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2954 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2955 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2956 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2957 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2958 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2959 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2960 const NDArray re_val = re.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2961
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2962 if (im.numel () == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2963 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2964 double im_val = im.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2965
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2966 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2967 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2968 ComplexNDArray result (re_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2969
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2970 for (octave_idx_type i = 0; i < re_val.numel (); i++)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2971 result.xelem (i) = Complex (re_val(i), im_val);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2972
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2973 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2974 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2975 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2976 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2977 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2978 const NDArray im_val = im.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2979
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2980 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2981 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2982 if (re_val.dims () == im_val.dims ())
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2983 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2984 ComplexNDArray result (re_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2985
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2986 for (octave_idx_type i = 0; i < re_val.numel (); i++)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2987 result.xelem (i) = Complex (re_val(i), im_val(i));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2988
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2989 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2990 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2991 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2992 error ("complex: dimension mismatch");
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2993 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2994 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2995 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2996
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2997 if (error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2998 error ("complex: invalid conversion");
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2999 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3000 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3001 print_usage ();
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3002
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3003 return retval;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3004 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3005
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3006 DEFUN (isreal, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3007 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3008 @deftypefn {Built-in Function} {} isreal (@var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3009 Return true if @var{x} is a real-valued numeric object.\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3010 @end deftypefn")
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3011 {
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3012 octave_value retval;
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3013
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3014 if (args.length () == 1)
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3015 retval = args(0).is_real_type ();
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3016 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3017 print_usage ();
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3018
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3019 return retval;
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3020 }
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3021
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3022 DEFUN (isempty, args, ,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3023 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3024 @deftypefn {Built-in Function} {} isempty (@var{a})\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3025 Return 1 if @var{a} is an empty matrix (either the number of rows, or\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3026 the number of columns, or both are zero). Otherwise, return 0.\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3027 @end deftypefn")
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3028 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3029 octave_value retval = false;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3030
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3031 if (args.length () == 1)
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	3032 retval = args(0).is_empty ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3033 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3034 print_usage ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3035
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3036 return retval;
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3037 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3038
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3039 DEFUN (isnumeric, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3040 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3041 @deftypefn {Built-in Function} {} isnumeric (@var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3042 Return nonzero if @var{x} is a numeric object.\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3043 @end deftypefn")
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3044 {
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3045 octave_value retval;
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3046
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3047 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3048 retval = args(0).is_numeric_type ();
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3049 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3050 print_usage ();
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3051
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3052 return retval;
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3053 }
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3054
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3055 DEFUN (islist, args, ,
3526 cc21933776a1 [project @ 2000-02-02 10:53:27 by jwe] jwe parents: 3523 diff changeset	3056 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3057 @deftypefn {Built-in Function} {} islist (@var{x})\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3058 Return nonzero if @var{x} is a list.\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3059 @end deftypefn")
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3060 {
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3061 octave_value retval;
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3062
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3063 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3064 retval = args(0).is_list ();
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3065 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3066 print_usage ();
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3067
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3068 return retval;
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3069 }
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3070
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3071 DEFUN (ismatrix, args, ,
3321 6923abb04e16 [project @ 1999-10-26 18:15:30 by jwe] jwe parents: 3307 diff changeset	3072 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3073 @deftypefn {Built-in Function} {} ismatrix (@var{a})\n\
3321 6923abb04e16 [project @ 1999-10-26 18:15:30 by jwe] jwe parents: 3307 diff changeset	3074 Return 1 if @var{a} is a matrix. Otherwise, return 0.\n\
3333 15cddaacbc2d [project @ 1999-11-03 19:53:59 by jwe] jwe parents: 3322 diff changeset	3075 @end deftypefn")
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3076 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3077 octave_value retval = false;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3078
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3079 if (args.length () == 1)
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3080 {
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3081 octave_value arg = args(0);
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3082
3212 bf61c443a366 [project @ 1998-11-05 04:24:45 by jwe] jwe parents: 3209 diff changeset	3083 if (arg.is_scalar_type () \|\| arg.is_range ())
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3084 retval = true;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3085 else if (arg.is_matrix_type ())
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3086 retval = (arg.rows () >= 1 && arg.columns () >= 1);
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3087 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3088 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3089 print_usage ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3090
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3091 return retval;
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3092 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3093
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3094 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3095
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3096 %!assert(ismatrix (1));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3097 %!assert(ismatrix ([1, 2, 3]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3098 %!assert(ismatrix ([1, 2; 3, 4]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3099
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3100 %% Yes, this is right, ismatrix() checks for non-empty matrices.
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3101 %!assert(ismatrix ([]), false);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3102
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3103 %!assert(ismatrix (single(1)));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3104 %!assert(ismatrix (single([1, 2, 3])));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3105 %!assert(ismatrix (single([1, 2; 3, 4])));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3106
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3107 %% Yes, this is right, ismatrix() checks for non-empty matrices.
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3108 %!assert(ismatrix (single([])), false);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3109
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3110 %!assert(ismatrix ("t"), false);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3111 %!assert(ismatrix ("test"), false);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3112 %!assert(ismatrix (["test"; "ing"]), false);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3113
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3114 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3115 %! s.a = 1;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3116 %! assert(ismatrix (s), false);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3117
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3118 %!error <Invalid call to ismatrix.*> ismatrix ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3119 %!error <Invalid call to ismatrix.*> ismatrix ([1, 2; 3, 4], 2);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3120
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3121 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3122
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3123 static octave_value
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3124 fill_matrix (const octave_value_list& args, int val, const char *fcn)
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3125 {
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3126 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3127
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3128 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3129
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3130 oct_data_conv::data_type dt = oct_data_conv::dt_double;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3131
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3132 dim_vector dims (1, 1);
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3133
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3134 if (nargin > 0 && args(nargin-1).is_string ())
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3135 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3136 std::string nm = args(nargin-1).string_value ();
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3137 nargin--;
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3138
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3139 dt = oct_data_conv::string_to_data_type (nm);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3140
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3141 if (error_state)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3142 return retval;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3143 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3144
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3145 switch (nargin)
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3146 {
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	3147 case 0:
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	3148 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3149
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	3150 case 1:
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3151 get_dimensions (args(0), fcn, dims);
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	3152 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3153
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3154 default:
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3155 {
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3156 dims.resize (nargin);
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3157
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3158 for (int i = 0; i < nargin; i++)
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3159 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3160 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value ();
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3161
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3162 if (error_state)
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3163 {
4732 b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	3164 error ("%s: expecting scalar integer arguments", fcn);
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3165 break;
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3166 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3167 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3168 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3169 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3170 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3171
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3172 if (! error_state)
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3173 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3174 dims.chop_trailing_singletons ();
4565 1db951a4fcd5 [project @ 2003-10-29 13:49:30 by jwe] jwe parents: 4563 diff changeset	3175
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3176 check_dimensions (dims, fcn);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3177
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	3178 // FIXME -- perhaps this should be made extensible by
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3179 // using the class name to lookup a function to call to create
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3180 // the new value.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3181
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3182 // Note that automatic narrowing will handle conversion from
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3183 // NDArray to scalar.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3184
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3185 if (! error_state)
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3186 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3187 switch (dt)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3188 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3189 case oct_data_conv::dt_int8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3190 retval = int8NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3191 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3192
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3193 case oct_data_conv::dt_uint8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3194 retval = uint8NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3195 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3196
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3197 case oct_data_conv::dt_int16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3198 retval = int16NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3199 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3200
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3201 case oct_data_conv::dt_uint16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3202 retval = uint16NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3203 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3204
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3205 case oct_data_conv::dt_int32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3206 retval = int32NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3207 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3208
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3209 case oct_data_conv::dt_uint32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3210 retval = uint32NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3211 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3212
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3213 case oct_data_conv::dt_int64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3214 retval = int64NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3215 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3216
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3217 case oct_data_conv::dt_uint64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3218 retval = uint64NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3219 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3220
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3221 case oct_data_conv::dt_single:
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3222 retval = FloatNDArray (dims, val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3223 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3224
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3225 case oct_data_conv::dt_double:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3226 retval = NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3227 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3228
4986 fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3229 case oct_data_conv::dt_logical:
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3230 retval = boolNDArray (dims, val);
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3231 break;
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3232
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3233 default:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3234 error ("%s: invalid class name", fcn);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3235 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3236 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3237 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3238 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3239
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3240 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3241 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3242
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3243 static octave_value
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3244 fill_matrix (const octave_value_list& args, double val, float fval,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3245 const char *fcn)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3246 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3247 octave_value retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3248
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3249 int nargin = args.length ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3250
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3251 oct_data_conv::data_type dt = oct_data_conv::dt_double;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3252
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3253 dim_vector dims (1, 1);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3254
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3255 if (nargin > 0 && args(nargin-1).is_string ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3256 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3257 std::string nm = args(nargin-1).string_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3258 nargin--;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3259
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3260 dt = oct_data_conv::string_to_data_type (nm);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3261
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3262 if (error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3263 return retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3264 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3265
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3266 switch (nargin)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3267 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3268 case 0:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3269 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3270
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3271 case 1:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3272 get_dimensions (args(0), fcn, dims);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3273 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3274
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3275 default:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3276 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3277 dims.resize (nargin);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3278
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3279 for (int i = 0; i < nargin; i++)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3280 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3281 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3282
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3283 if (error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3284 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3285 error ("%s: expecting scalar integer arguments", fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3286 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3287 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3288 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3289 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3290 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3291 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3292
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3293 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3294 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3295 dims.chop_trailing_singletons ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3296
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3297 check_dimensions (dims, fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3298
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3299 // Note that automatic narrowing will handle conversion from
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3300 // NDArray to scalar.
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3301
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3302 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3303 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3304 switch (dt)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3305 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3306 case oct_data_conv::dt_single:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3307 retval = FloatNDArray (dims, fval);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3308 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3309
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3310 case oct_data_conv::dt_double:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3311 retval = NDArray (dims, val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3312 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3313
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3314 default:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3315 error ("%s: invalid class name", fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3316 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3317 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3318 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3319 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3320
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3321 return retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3322 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3323
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3324 static octave_value
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3325 fill_matrix (const octave_value_list& args, double val, const char *fcn)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3326 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3327 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3328
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3329 int nargin = args.length ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3330
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3331 oct_data_conv::data_type dt = oct_data_conv::dt_double;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3332
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3333 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3334
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3335 if (nargin > 0 && args(nargin-1).is_string ())
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3336 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3337 std::string nm = args(nargin-1).string_value ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3338 nargin--;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3339
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3340 dt = oct_data_conv::string_to_data_type (nm);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3341
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3342 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3343 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3344 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3345
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3346 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3347 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3348 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3349 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3350
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3351 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3352 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3353 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3354
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3355 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3356 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3357 dims.resize (nargin);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3358
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3359 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3360 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3361 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value ();
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3362
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3363 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3364 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3365 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3366 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3367 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3368 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3369 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3370 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3371 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3372
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3373 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3374 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3375 dims.chop_trailing_singletons ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3376
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3377 check_dimensions (dims, fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3378
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3379 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3380 // NDArray to scalar.
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3381
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3382 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3383 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3384 switch (dt)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3385 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3386 case oct_data_conv::dt_single:
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3387 retval = FloatNDArray (dims, static_cast <float> (val));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3388 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3389
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3390 case oct_data_conv::dt_double:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3391 retval = NDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3392 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3393
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3394 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3395 error ("%s: invalid class name", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3396 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3397 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3398 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3399 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3400
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3401 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3402 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3403
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3404 static octave_value
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3405 fill_matrix (const octave_value_list& args, const Complex& val,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3406 const char *fcn)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3407 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3408 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3409
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3410 int nargin = args.length ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3411
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3412 oct_data_conv::data_type dt = oct_data_conv::dt_double;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3413
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3414 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3415
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3416 if (nargin > 0 && args(nargin-1).is_string ())
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3417 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3418 std::string nm = args(nargin-1).string_value ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3419 nargin--;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3420
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3421 dt = oct_data_conv::string_to_data_type (nm);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3422
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3423 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3424 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3425 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3426
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3427 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3428 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3429 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3430 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3431
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3432 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3433 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3434 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3435
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3436 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3437 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3438 dims.resize (nargin);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3439
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3440 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3441 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3442 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value ();
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3443
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3444 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3445 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3446 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3447 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3448 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3449 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3450 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3451 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3452 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3453
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3454 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3455 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3456 dims.chop_trailing_singletons ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3457
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3458 check_dimensions (dims, fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3459
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3460 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3461 // NDArray to scalar.
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3462
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3463 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3464 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3465 switch (dt)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3466 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3467 case oct_data_conv::dt_single:
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3468 retval = FloatComplexNDArray (dims, static_cast<FloatComplex> (val));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3469 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3470
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3471 case oct_data_conv::dt_double:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3472 retval = ComplexNDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3473 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3474
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3475 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3476 error ("%s: invalid class name", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3477 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3478 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3479 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3480 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3481
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3482 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3483 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3484
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3485 static octave_value
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3486 fill_matrix (const octave_value_list& args, bool val, const char *fcn)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3487 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3488 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3489
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3490 int nargin = args.length ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3491
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3492 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3493
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3494 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3495 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3496 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3497 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3498
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3499 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3500 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3501 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3502
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3503 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3504 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3505 dims.resize (nargin);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3506
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3507 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3508 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3509 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value ();
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3510
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3511 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3512 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3513 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3514 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3515 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3516 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3517 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3518 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3519 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3520
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3521 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3522 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3523 dims.chop_trailing_singletons ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3524
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3525 check_dimensions (dims, fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3526
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3527 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3528 // NDArray to scalar.
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3529
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3530 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3531 retval = boolNDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3532 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3533
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3534 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3535 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3536
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3537 DEFUN (ones, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3538 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3539 @deftypefn {Built-in Function} {} ones (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3540 @deftypefnx {Built-in Function} {} ones (@var{n}, @var{m})\n\
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	3541 @deftypefnx {Built-in Function} {} ones (@var{n}, @var{m}, @var{k}, @dots{})\n\
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	3542 @deftypefnx {Built-in Function} {} ones (@dots{}, @var{class})\n\
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3543 Return a matrix or N-dimensional array whose elements are all 1.\n\
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3544 The arguments are handled the same as the arguments for @code{eye}.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3545 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3546 If you need to create a matrix whose values are all the same, you should\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3547 use an expression like\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3548 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3549 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3550 val_matrix = val * ones (n, m)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3551 @end example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3552 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3553 The optional argument @var{class}, allows @code{ones} to return an array of\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3554 the specified type, for example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3555 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3556 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3557 val = ones (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3558 @end example\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3559 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3560 {
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3561 return fill_matrix (args, 1, "ones");
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3562 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3563
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3564 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3565
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3566 %!assert(ones (3), [1, 1, 1; 1, 1, 1; 1, 1, 1]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3567 %!assert(ones (2, 3), [1, 1, 1; 1, 1, 1]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3568 %!assert(ones (3, 2), [1, 1; 1, 1; 1, 1]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3569 %!assert(size (ones (3, 4, 5)), [3, 4, 5]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3570
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3571 %!assert(ones (3,'single'), single([1, 1, 1; 1, 1, 1; 1, 1, 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3572 %!assert(ones (2, 3,'single'), single([1, 1, 1; 1, 1, 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3573 %!assert(ones (3, 2,'single'), single([1, 1; 1, 1; 1, 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3574 %!assert(size (ones (3, 4, 5, 'single')), [3, 4, 5]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3575
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3576 %!assert(ones (3,'int8'), int8([1, 1, 1; 1, 1, 1; 1, 1, 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3577 %!assert(ones (2, 3,'int8'), int8([1, 1, 1; 1, 1, 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3578 %!assert(ones (3, 2,'int8'), int8([1, 1; 1, 1; 1, 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3579 %!assert(size (ones (3, 4, 5, 'int8')), [3, 4, 5]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3580
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3581 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3582
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3583 DEFUN (zeros, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3584 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3585 @deftypefn {Built-in Function} {} zeros (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3586 @deftypefnx {Built-in Function} {} zeros (@var{n}, @var{m})\n\
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	3587 @deftypefnx {Built-in Function} {} zeros (@var{n}, @var{m}, @var{k}, @dots{})\n\
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	3588 @deftypefnx {Built-in Function} {} zeros (@dots{}, @var{class})\n\
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3589 Return a matrix or N-dimensional array whose elements are all 0.\n\
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3590 The arguments are handled the same as the arguments for @code{eye}.\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3591 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3592 The optional argument @var{class}, allows @code{zeros} to return an array of\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3593 the specified type, for example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3594 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3595 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3596 val = zeros (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3597 @end example\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3598 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3599 {
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3600 return fill_matrix (args, 0, "zeros");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3601 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3602
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3603 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3604
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3605 %!assert(zeros (3), [0, 0, 0; 0, 0, 0; 0, 0, 0]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3606 %!assert(zeros (2, 3), [0, 0, 0; 0, 0, 0]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3607 %!assert(zeros (3, 2), [0, 0; 0, 0; 0, 0]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3608 %!assert(size (zeros (3, 4, 5)), [3, 4, 5]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3609
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3610 %!assert(zeros (3,'single'), single([0, 0, 0; 0, 0, 0; 0, 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3611 %!assert(zeros (2, 3,'single'), single([0, 0, 0; 0, 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3612 %!assert(zeros (3, 2,'single'), single([0, 0; 0, 0; 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3613 %!assert(size (zeros (3, 4, 5, 'single')), [3, 4, 5]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3614
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3615 %!assert(zeros (3,'int8'), int8([0, 0, 0; 0, 0, 0; 0, 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3616 %!assert(zeros (2, 3,'int8'), int8([0, 0, 0; 0, 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3617 %!assert(zeros (3, 2,'int8'), int8([0, 0; 0, 0; 0, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3618 %!assert(size (zeros (3, 4, 5, 'int8')), [3, 4, 5]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3619
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3620 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3621
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3622 DEFUN (Inf, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3623 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3624 @deftypefn {Built-in Function} {} Inf (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3625 @deftypefnx {Built-in Function} {} Inf (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3626 @deftypefnx {Built-in Function} {} Inf (@var{n}, @var{m}, @var{k}, @dots{})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3627 @deftypefnx {Built-in Function} {} Inf (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3628 Return a matrix or N-dimensional array whose elements are all Infinity.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3629 The arguments are handled the same as the arguments for @code{eye}.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3630 The optional argument @var{class} may be either @samp{\"single\"} or\n\
5798 7e7ed81f5566 [project @ 2006-05-09 17:24:33 by jwe] jwe parents: 5775 diff changeset	3631 @samp{\"double\"}. The default is @samp{\"double\"}.\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3632 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3633 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3634 return fill_matrix (args, lo_ieee_inf_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3635 lo_ieee_float_inf_value (), "Inf");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3636 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3637
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3638 DEFALIAS (inf, Inf);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3639
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3640 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3641
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3642 %!assert(inf (3), [Inf, Inf, Inf; Inf, Inf, Inf; Inf, Inf, Inf]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3643 %!assert(inf (2, 3), [Inf, Inf, Inf; Inf, Inf, Inf]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3644 %!assert(inf (3, 2), [Inf, Inf; Inf, Inf; Inf, Inf]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3645 %!assert(size (inf (3, 4, 5)), [3, 4, 5]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3646
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3647 %!assert(inf (3,'single'), single([Inf, Inf, Inf; Inf, Inf, Inf; Inf, Inf, Inf]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3648 %!assert(inf (2, 3,'single'), single([Inf, Inf, Inf; Inf, Inf, Inf]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3649 %!assert(inf (3, 2,'single'), single([Inf, Inf; Inf, Inf; Inf, Inf]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3650 %!assert(size (inf (3, 4, 5, 'single')), [3, 4, 5]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3651
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3652 %!error(inf (3,'int8'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3653 %!error(inf (2, 3,'int8'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3654 %!error(inf (3, 2,'int8'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3655 %!error(inf (3, 4, 5, 'int8'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3656
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3657 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3658
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3659 DEFUN (NaN, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3660 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3661 @deftypefn {Built-in Function} {} NaN (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3662 @deftypefnx {Built-in Function} {} NaN (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3663 @deftypefnx {Built-in Function} {} NaN (@var{n}, @var{m}, @var{k}, @dots{})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3664 @deftypefnx {Built-in Function} {} NaN (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3665 Return a matrix or N-dimensional array whose elements are all NaN\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3666 (Not a Number). The value NaN is the result of an operation like\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3667 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3668 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3669 $0/0$, or $\\infty - \\infty$,\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3670 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3671 @end iftex\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3672 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3673 0/0, or @samp{Inf - Inf},\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3674 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3675 or any operation with a NaN.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3676 \n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3677 Note that NaN always compares not equal to NaN. This behavior is\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3678 specified by the IEEE standard for floating point arithmetic. To\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3679 find NaN values, you must use the @code{isnan} function.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3680 \n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3681 The arguments are handled the same as the arguments for @code{eye}.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3682 The optional argument @var{class} may be either @samp{\"single\"} or\n\
5798 7e7ed81f5566 [project @ 2006-05-09 17:24:33 by jwe] jwe parents: 5775 diff changeset	3683 @samp{\"double\"}. The default is @samp{\"double\"}.\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3684 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3685 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3686 return fill_matrix (args, lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3687 lo_ieee_float_nan_value (), "NaN");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3688 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3689
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3690 DEFALIAS (nan, NaN);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3691
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3692 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3693 %!assert(NaN (3), [NaN, NaN, NaN; NaN, NaN, NaN; NaN, NaN, NaN]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3694 %!assert(NaN (2, 3), [NaN, NaN, NaN; NaN, NaN, NaN]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3695 %!assert(NaN (3, 2), [NaN, NaN; NaN, NaN; NaN, NaN]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3696 %!assert(size (NaN (3, 4, 5)), [3, 4, 5]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3697
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3698 %!assert(NaN (3,'single'), single([NaN, NaN, NaN; NaN, NaN, NaN; NaN, NaN, NaN]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3699 %!assert(NaN (2, 3,'single'), single([NaN, NaN, NaN; NaN, NaN, NaN]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3700 %!assert(NaN (3, 2,'single'), single([NaN, NaN; NaN, NaN; NaN, NaN]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3701 %!assert(size (NaN (3, 4, 5, 'single')), [3, 4, 5]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3702
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3703 %!error(NaN (3,'int8'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3704 %!error(NaN (2, 3,'int8'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3705 %!error(NaN (3, 2,'int8'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3706 %!error(NaN (3, 4, 5, 'int8'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3707
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3708 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3709
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3710 DEFUN (e, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3711 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3712 @deftypefn {Built-in Function} {} e (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3713 @deftypefnx {Built-in Function} {} e (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3714 @deftypefnx {Built-in Function} {} e (@var{n}, @var{m}, @var{k}, @dots{})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3715 @deftypefnx {Built-in Function} {} e (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3716 Return a matrix or N-dimensional array whose elements are all equal\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3717 to the base of natural logarithms. The constant\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3718 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3719 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3720 $e$\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3721 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3722 @end iftex\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3723 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3724 @var{e}\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3725 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3726 satisfies the equation\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3727 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3728 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3729 $\\log (e) = 1$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3730 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3731 @end iftex\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3732 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3733 @code{log} (@var{e}) = 1.\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3734 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3735 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3736 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3737 #if defined (M_E)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3738 double e_val = M_E;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3739 #else
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3740 double e_val = exp (1.0);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3741 #endif
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3742
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3743 return fill_matrix (args, e_val, "e");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3744 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3745
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3746 DEFUN (eps, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3747 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3748 @deftypefn {Built-in Function} {} eps (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3749 @deftypefnx {Built-in Function} {} eps (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3750 @deftypefnx {Built-in Function} {} eps (@var{n}, @var{m}, @var{k}, @dots{})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3751 @deftypefnx {Built-in Function} {} eps (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3752 Return a matrix or N-dimensional array whose elements are all eps,\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3753 the machine precision. More precisely, @code{eps} is the largest\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3754 relative spacing between any two adjacent numbers in the machine's\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3755 floating point system. This number is obviously system-dependent. On\n\
8487 5701c2fe3327 [docs] 64 bit => 64-bit Brian Gough <bjg@gnu.org> parents: 8459 diff changeset	3756 machines that support 64-bit IEEE floating point arithmetic, @code{eps}\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3757 is approximately\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3758 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3759 2.2204e-16.\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3760 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3761 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3762 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3763 $2.2204\\times10^{-16}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3764 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3765 @end iftex\n\
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3766 for double precision and\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3767 @ifnottex\n\
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3768 1.1921e-07.\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3769 @end ifnottex\n\
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3770 @iftex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3771 @tex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3772 $1.1921\\times10^{-7}$.\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3773 @end tex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3774 @end iftex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3775 for single precision. Given a single argument @var{x}, return the\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3776 distance between @var{x} and the next largest value.\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3777 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3778 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3779 int nargin = args.length ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3780 octave_value retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3781
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3782 if (nargin == 1 && ! args(0).is_string ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3783 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3784 if (args(0).is_single_type ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3785 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3786 float val = args(0).float_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3787
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3788 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3789 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3790 val = ::fabsf(val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3791 if (xisnan (val) \|\| xisinf (val))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3792 retval = fill_matrix (octave_value ("single"),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3793 lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3794 lo_ieee_float_nan_value (), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3795 else if (val < FLT_MIN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3796 retval = fill_matrix (octave_value ("single"), 0e0,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3797 powf (2.0, -149e0), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3798 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3799 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3800 int expon;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3801 frexpf (val, &expon);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3802 val = std::pow (static_cast <float> (2.0),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3803 static_cast <float> (expon - 24));
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3804 retval = fill_matrix (octave_value ("single"), DBL_EPSILON,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3805 val, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3806 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3807 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3808 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3809 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3810 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3811 double val = args(0).double_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3812
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3813 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3814 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3815 val = ::fabs(val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3816 if (xisnan (val) \|\| xisinf (val))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3817 retval = fill_matrix (octave_value_list (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3818 lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3819 lo_ieee_float_nan_value (), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3820 else if (val < DBL_MIN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3821 retval = fill_matrix (octave_value_list (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3822 pow (2.0, -1074e0), 0e0, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3823 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3824 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3825 int expon;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3826 frexp (val, &expon);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3827 val = std::pow (static_cast <double> (2.0),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3828 static_cast <double> (expon - 53));
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3829 retval = fill_matrix (octave_value_list (), val,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3830 FLT_EPSILON, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3831 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3832 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3833 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3834 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3835 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3836 retval = fill_matrix (args, DBL_EPSILON, FLT_EPSILON, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3837
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3838 return retval;
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3839 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3840
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3841 /*
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3842
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3843 %!assert(eps(1/2),2^(-53))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3844 %!assert(eps(1),2^(-52))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3845 %!assert(eps(2),2^(-51))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3846 %!assert(eps(realmax),2^971)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3847 %!assert(eps(0),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3848 %!assert(eps(realmin/2),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3849 %!assert(eps(realmin/16),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3850 %!assert(eps(Inf),NaN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3851 %!assert(eps(NaN),NaN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3852 %!assert(eps(single(1/2)),single(2^(-24)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3853 %!assert(eps(single(1)),single(2^(-23)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3854 %!assert(eps(single(2)),single(2^(-22)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3855 %!assert(eps(realmax('single')),single(2^104))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3856 %!assert(eps(single(0)),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3857 %!assert(eps(realmin('single')/2),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3858 %!assert(eps(realmin('single')/16),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3859 %!assert(eps(single(Inf)),single(NaN))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3860 %!assert(eps(single(NaN)),single(NaN))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3861
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3862 */
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3863
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3864
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3865 DEFUN (pi, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3866 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3867 @deftypefn {Built-in Function} {} pi (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3868 @deftypefnx {Built-in Function} {} pi (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3869 @deftypefnx {Built-in Function} {} pi (@var{n}, @var{m}, @var{k}, @dots{})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3870 @deftypefnx {Built-in Function} {} pi (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3871 Return a matrix or N-dimensional array whose elements are all equal\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3872 to the ratio of the circumference of a circle to its diameter.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3873 Internally, @code{pi} is computed as @samp{4.0 * atan (1.0)}.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3874 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3875 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3876 #if defined (M_PI)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3877 double pi_val = M_PI;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3878 #else
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3879 double pi_val = 4.0 * atan (1.0);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3880 #endif
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3881
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3882 return fill_matrix (args, pi_val, "pi");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3883 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3884
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3885 DEFUN (realmax, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3886 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3887 @deftypefn {Built-in Function} {} realmax (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3888 @deftypefnx {Built-in Function} {} realmax (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3889 @deftypefnx {Built-in Function} {} realmax (@var{n}, @var{m}, @var{k}, @dots{})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3890 @deftypefnx {Built-in Function} {} realmax (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3891 Return a matrix or N-dimensional array whose elements are all equal\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3892 to the largest floating point number that is representable. The actual\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3893 value is system-dependent. On machines that support 64-bit IEEE\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3894 floating point arithmetic, @code{realmax} is approximately\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3895 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3896 1.7977e+308\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3897 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3898 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3899 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3900 $1.7977\\times10^{308}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3901 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3902 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3903 @seealso{realmin}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3904 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3905 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3906 return fill_matrix (args, DBL_MAX, FLT_MAX, "realmax");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3907 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3908
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3909 DEFUN (realmin, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3910 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3911 @deftypefn {Built-in Function} {} realmin (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3912 @deftypefnx {Built-in Function} {} realmin (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3913 @deftypefnx {Built-in Function} {} realmin (@var{n}, @var{m}, @var{k}, @dots{})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3914 @deftypefnx {Built-in Function} {} realmin (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3915 Return a matrix or N-dimensional array whose elements are all equal\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3916 to the smallest normalized floating point number that is representable.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3917 The actual value is system-dependent. On machines that support\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3918 64-bit IEEE floating point arithmetic, @code{realmin} is approximately\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3919 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3920 2.2251e-308\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3921 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3922 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3923 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3924 $2.2251\\times10^{-308}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3925 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3926 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3927 @seealso{realmax}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3928 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3929 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3930 return fill_matrix (args, DBL_MIN, FLT_MIN, "realmin");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3931 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3932
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3933 DEFUN (I, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3934 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3935 @deftypefn {Built-in Function} {} I (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3936 @deftypefnx {Built-in Function} {} I (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3937 @deftypefnx {Built-in Function} {} I (@var{n}, @var{m}, @var{k}, @dots{})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3938 @deftypefnx {Built-in Function} {} I (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3939 Return a matrix or N-dimensional array whose elements are all equal\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3940 to the pure imaginary unit, defined as\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3941 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3942 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3943 $\\sqrt{-1}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3944 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3945 @end iftex\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3946 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3947 @code{sqrt (-1)}.\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3948 @end ifnottex\n\
7001 8b0cfeb06365 [project @ 2007-10-10 18:02:59 by jwe] jwe parents: 6999 diff changeset	3949 Since I (also i, J, and j) is a function, you can use the name(s) for\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3950 other purposes.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3951 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3952 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3953 return fill_matrix (args, Complex (0.0, 1.0), "I");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3954 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3955
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3956 DEFALIAS (i, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3957 DEFALIAS (J, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3958 DEFALIAS (j, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3959
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3960 DEFUN (NA, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3961 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3962 @deftypefn {Built-in Function} {} NA (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3963 @deftypefnx {Built-in Function} {} NA (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3964 @deftypefnx {Built-in Function} {} NA (@var{n}, @var{m}, @var{k}, @dots{})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3965 @deftypefnx {Built-in Function} {} NA (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3966 Return a matrix or N-dimensional array whose elements are all equal\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3967 to the special constant used to designate missing values.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3968 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3969 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3970 return fill_matrix (args, lo_ieee_na_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3971 lo_ieee_float_na_value (), "NA");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3972 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3973
7991 139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3974 /*
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3975
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3976 %!assert(single(NA('double')),NA('single'))
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3977 %!assert(double(NA('single')),NA('double'))
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3978
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3979 */
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3980
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3981 DEFUN (false, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3982 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3983 @deftypefn {Built-in Function} {} false (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3984 @deftypefnx {Built-in Function} {} false (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3985 @deftypefnx {Built-in Function} {} false (@var{n}, @var{m}, @var{k}, @dots{})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3986 Return a matrix or N-dimensional array whose elements are all logical 0.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3987 The arguments are handled the same as the arguments for @code{eye}.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3988 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3989 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3990 return fill_matrix (args, false, "false");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3991 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3992
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3993 DEFUN (true, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3994 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3995 @deftypefn {Built-in Function} {} true (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3996 @deftypefnx {Built-in Function} {} true (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3997 @deftypefnx {Built-in Function} {} true (@var{n}, @var{m}, @var{k}, @dots{})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3998 Return a matrix or N-dimensional array whose elements are all logical 1.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3999 The arguments are handled the same as the arguments for @code{eye}.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4000 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4001 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4002 return fill_matrix (args, true, "true");
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4003 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4004
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4005 template <class MT>
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4006 octave_value
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4007 identity_matrix (int nr, int nc)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4008 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4009 octave_value retval;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4010
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4011 typename octave_array_type_traits<MT>::element_type one (1);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4012
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4013 if (nr == 1 && nc == 1)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4014 retval = one;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4015 else
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4016 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4017 dim_vector dims (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4018
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4019 typename octave_array_type_traits<MT>::element_type zero (0);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4020
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4021 MT m (dims, zero);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4022
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4023 if (nr > 0 && nc > 0)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4024 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4025 int n = std::min (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4026
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4027 for (int i = 0; i < n; i++)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4028 m(i,i) = one;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4029 }
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4030
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4031 retval = m;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4032 }
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4033
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4034 return retval;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4035 }
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4036
5058 11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4037 #define INSTANTIATE_EYE(T) \
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4038 template octave_value identity_matrix<T> (int, int)
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4039
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4040 INSTANTIATE_EYE (int8NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4041 INSTANTIATE_EYE (uint8NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4042 INSTANTIATE_EYE (int16NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4043 INSTANTIATE_EYE (uint16NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4044 INSTANTIATE_EYE (int32NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4045 INSTANTIATE_EYE (uint32NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4046 INSTANTIATE_EYE (int64NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4047 INSTANTIATE_EYE (uint64NDArray);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4048 INSTANTIATE_EYE (FloatNDArray);
5058 11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4049 INSTANTIATE_EYE (NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4050 INSTANTIATE_EYE (boolNDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4051
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4052 static octave_value
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4053 identity_matrix (int nr, int nc, oct_data_conv::data_type dt)
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4054 {
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4055 octave_value retval;
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4056
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4057 // FIXME -- perhaps this should be made extensible by using
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4058 // the class name to lookup a function to call to create the new
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4059 // value.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4060
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4061 if (! error_state)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4062 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4063 switch (dt)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4064 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4065 case oct_data_conv::dt_int8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4066 retval = identity_matrix<int8NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4067 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4068
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4069 case oct_data_conv::dt_uint8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4070 retval = identity_matrix<uint8NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4071 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4072
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4073 case oct_data_conv::dt_int16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4074 retval = identity_matrix<int16NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4075 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4076
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4077 case oct_data_conv::dt_uint16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4078 retval = identity_matrix<uint16NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4079 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4080
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4081 case oct_data_conv::dt_int32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4082 retval = identity_matrix<int32NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4083 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4084
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4085 case oct_data_conv::dt_uint32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4086 retval = identity_matrix<uint32NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4087 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4088
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4089 case oct_data_conv::dt_int64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4090 retval = identity_matrix<int64NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4091 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4092
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4093 case oct_data_conv::dt_uint64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4094 retval = identity_matrix<uint64NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4095 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4096
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4097 case oct_data_conv::dt_single:
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	4098 retval = FloatDiagMatrix (nr, nc, 1.0f);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4099 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4100
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4101 case oct_data_conv::dt_double:
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	4102 retval = DiagMatrix (nr, nc, 1.0);
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4103 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4104
4986 fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4105 case oct_data_conv::dt_logical:
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4106 retval = identity_matrix<boolNDArray> (nr, nc);
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4107 break;
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4108
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4109 default:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4110 error ("eye: invalid class name");
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4111 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4112 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4113 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4114
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4115 return retval;
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4116 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4117
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4118 #undef INT_EYE_MATRIX
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4119
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	4120 DEFUN (eye, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4121 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4122 @deftypefn {Built-in Function} {} eye (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4123 @deftypefnx {Built-in Function} {} eye (@var{n}, @var{m})\n\
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4124 @deftypefnx {Built-in Function} {} eye (@dots{}, @var{class})\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4125 Return an identity matrix. If invoked with a single scalar argument,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4126 @code{eye} returns a square matrix with the dimension specified. If you\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4127 supply two scalar arguments, @code{eye} takes them to be the number of\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4128 rows and columns. If given a vector with two elements, @code{eye} uses\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4129 the values of the elements as the number of rows and columns,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4130 respectively. For example,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4131 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4132 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4133 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4134 eye (3)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4135 @result{} 1 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4136 0 1 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4137 0 0 1\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4138 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4139 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4140 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4141 The following expressions all produce the same result:\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4142 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4143 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4144 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4145 eye (2)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4146 @equiv{}\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4147 eye (2, 2)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4148 @equiv{}\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4149 eye (size ([1, 2; 3, 4])\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4150 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4151 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4152 \n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4153 The optional argument @var{class}, allows @code{eye} to return an array of\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4154 the specified type, like\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4155 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4156 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4157 val = zeros (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4158 @end example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4159 \n\
6556 8810bbf321ce [project @ 2007-04-20 18:39:40 by jwe] jwe parents: 6518 diff changeset	4160 Calling @code{eye} with no arguments is equivalent to calling it\n\
8810bbf321ce [project @ 2007-04-20 18:39:40 by jwe] jwe parents: 6518 diff changeset	4161 with an argument of 1. This odd definition is for compatibility\n\
8810bbf321ce [project @ 2007-04-20 18:39:40 by jwe] jwe parents: 6518 diff changeset	4162 with @sc{Matlab}.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4163 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4164 {
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4165 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4166
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4167 int nargin = args.length ();
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4168
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4169 oct_data_conv::data_type dt = oct_data_conv::dt_double;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4170
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4171 // Check for type information.
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4172
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4173 if (nargin > 0 && args(nargin-1).is_string ())
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4174 {
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4175 std::string nm = args(nargin-1).string_value ();
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4176 nargin--;
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4177
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4178 dt = oct_data_conv::string_to_data_type (nm);
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4179
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4180 if (error_state)
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4181 return retval;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4182 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4183
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4184 switch (nargin)
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4185 {
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	4186 case 0:
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4187 retval = identity_matrix (1, 1, dt);
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	4188 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4189
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	4190 case 1:
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4191 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4192 octave_idx_type nr, nc;
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4193 get_dimensions (args(0), "eye", nr, nc);
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4194
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4195 if (! error_state)
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4196 retval = identity_matrix (nr, nc, dt);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4197 }
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	4198 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4199
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4200 case 2:
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4201 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4202 octave_idx_type nr, nc;
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4203 get_dimensions (args(0), args(1), "eye", nr, nc);
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4204
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4205 if (! error_state)
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4206 retval = identity_matrix (nr, nc, dt);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4207 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4208 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4209
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4210 default:
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4211 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4212 break;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4213 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4214
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4215 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4216 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4217
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4218
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4219 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4220
8459 d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4221 %!assert (full (eye(3)), [1, 0, 0; 0, 1, 0; 0, 0, 1]);
d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4222 %!assert (full (eye(2, 3)), [1, 0, 0; 0, 1, 0]);
d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4223
d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4224 %!assert (full (eye(3,'single')), single([1, 0, 0; 0, 1, 0; 0, 0, 1]));
d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4225 %!assert (full (eye(2, 3,'single')), single([1, 0, 0; 0, 1, 0]));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4226
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4227 %!assert (eye(3,'int8'), int8([1, 0, 0; 0, 1, 0; 0, 0, 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4228 %!assert (eye(2, 3,'int8'), int8([1, 0, 0; 0, 1, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4229
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4230 %!error <Invalid call to eye.*> eye (1, 2, 3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4231
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4232 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4233
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	4234 DEFUN (linspace, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4235 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4236 @deftypefn {Built-in Function} {} linspace (@var{base}, @var{limit}, @var{n})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4237 Return a row vector with @var{n} linearly spaced elements between\n\
6630 0fcc8d65b571 [project @ 2007-05-16 15:32:09 by jwe] jwe parents: 6561 diff changeset	4238 @var{base} and @var{limit}. If the number of elements is greater than one,\n\
0fcc8d65b571 [project @ 2007-05-16 15:32:09 by jwe] jwe parents: 6561 diff changeset	4239 then the @var{base} and @var{limit} are always included in\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4240 the range. If @var{base} is greater than @var{limit}, the elements are\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4241 stored in decreasing order. If the number of points is not specified, a\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4242 value of 100 is used.\n\
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4243 \n\
4455 abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4358 diff changeset	4244 The @code{linspace} function always returns a row vector.\n\
6630 0fcc8d65b571 [project @ 2007-05-16 15:32:09 by jwe] jwe parents: 6561 diff changeset	4245 \n\
0fcc8d65b571 [project @ 2007-05-16 15:32:09 by jwe] jwe parents: 6561 diff changeset	4246 For compatibility with @sc{Matlab}, return the second argument if\n\
0fcc8d65b571 [project @ 2007-05-16 15:32:09 by jwe] jwe parents: 6561 diff changeset	4247 fewer than two values are requested.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4248 @end deftypefn")
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4249 {
3418 ca92c9d3f882 [project @ 2000-01-12 03:07:47 by jwe] jwe parents: 3373 diff changeset	4250 octave_value retval;
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4251
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4252 int nargin = args.length ();
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4253
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4254 octave_idx_type npoints = 100;
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4255
1940 1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4256 if (nargin != 2 && nargin != 3)
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4257 {
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4258 print_usage ();
1940 1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4259 return retval;
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4260 }
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4261
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4262 if (nargin == 3)
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4263 npoints = args(2).idx_type_value ();
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4264
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4265 if (! error_state)
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4266 {
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4267 octave_value arg_1 = args(0);
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4268 octave_value arg_2 = args(1);
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4269
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4270 if (arg_1.is_single_type () \|\| arg_2.is_single_type ())
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4271 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4272 if (arg_1.is_complex_type () \|\| arg_2.is_complex_type ())
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4273 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4274 FloatComplex x1 = arg_1.float_complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4275 FloatComplex x2 = arg_2.float_complex_value ();
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4276
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4277 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4278 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4279 FloatComplexRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4280
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4281 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4282 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4283 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4284 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4285 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4286 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4287 float x1 = arg_1.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4288 float x2 = arg_2.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4289
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4290 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4291 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4292 FloatRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4293
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4294 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4295 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4296 }
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4297 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4298 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4299 else
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4300 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4301 if (arg_1.is_complex_type () \|\| arg_2.is_complex_type ())
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4302 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4303 Complex x1 = arg_1.complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4304 Complex x2 = arg_2.complex_value ();
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4305
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4306 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4307 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4308 ComplexRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4309
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4310 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4311 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4312 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4313 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4314 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4315 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4316 double x1 = arg_1.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4317 double x2 = arg_2.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4318
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4319 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4320 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4321 RowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4322
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4323 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4324 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4325 }
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4326 }
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4327 }
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4328 }
4732 b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	4329 else
b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	4330 error ("linspace: expecting third argument to be an integer");
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4331
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4332 return retval;
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4333 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4334
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4335
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4336 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4337
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4338 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4339 %! x1 = linspace (1, 2);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4340 %! x2 = linspace (1, 2, 10);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4341 %! x3 = linspace (1, -2, 10);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4342 %! assert((size (x1) == [1, 100] && x1(1) == 1 && x1(100) == 2
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4343 %! && size (x2) == [1, 10] && x2(1) == 1 && x2(10) == 2
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4344 %! && size (x3) == [1, 10] && x3(1) == 1 && x3(10) == -2));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4345
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4346
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4347 % assert(linspace ([1, 2; 3, 4], 5, 6), linspace (1, 5, 6));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4348
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4349 %!error <Invalid call to linspace.*> linspace ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4350 %!error <Invalid call to linspace.*> linspace (1, 2, 3, 4);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4351
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4352 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4353 %! fail("linspace ([1, 2; 3, 4], 5, 6)","warning");
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4354
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4355 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4356
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4357 // FIXME -- should accept dimensions as separate args for N-d
5734 a7d2c47371d2 [project @ 2006-04-04 18:29:13 by jwe] jwe parents: 5731 diff changeset	4358 // arrays as well as 1-d and 2-d arrays.
a7d2c47371d2 [project @ 2006-04-04 18:29:13 by jwe] jwe parents: 5731 diff changeset	4359
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4360 DEFUN (resize, args, ,
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4361 "-- texinfo --\n\
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4362 @deftypefn {Built-in Function} {} resize (@var{x}, @var{m})\n\
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4363 @deftypefnx {Built-in Function} {} resize (@var{x}, @var{m}, @var{n})\n\
6174 d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4364 Destructively resize @var{x}.\n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4365 \n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4366 @strong{Values in @var{x} are not preserved as they are with\n\
6175 a4ecbadedc17 [project @ 2006-11-16 18:19:20 by jwe] jwe parents: 6174 diff changeset	4367 @code{reshape}.}\n\
6174 d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4368 \n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4369 If only @var{m} is supplied and it is a scalar, the dimension of the\n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4370 result is @var{m}-by-@var{m}. If @var{m} is a vector, then the\n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4371 dimensions of the result are given by the elements of @var{m}.\n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4372 If both @var{m} and @var{n} are scalars, then the dimensions of\n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4373 the result are @var{m}-by-@var{n}.\n\
8433 3292bd1bbaa4 Cross reference between postpad and resize Francesco PotortÃ¬ <pot@gnu.org> parents: 8429 diff changeset	4374 @seealso{reshape, postpad}\n\
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4375 @end deftypefn")
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4376 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4377 octave_value retval;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4378 int nargin = args.length ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4379
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4380 if (nargin == 2)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4381 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4382 Array<double> vec = args(1).vector_value ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4383 int ndim = vec.length ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4384 if (ndim == 1)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4385 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4386 octave_idx_type m = static_cast<octave_idx_type> (vec(0));
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4387 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4388 retval = retval.resize (dim_vector (m, m), true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4389 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4390 else
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4391 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4392 dim_vector dv;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4393 dv.resize (ndim);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4394 for (int i = 0; i < ndim; i++)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4395 dv(i) = static_cast<octave_idx_type> (vec(i));
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4396 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4397 retval = retval.resize (dv, true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4398 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4399 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4400 else if (nargin == 3)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4401 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4402 octave_idx_type m = static_cast<octave_idx_type>
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4403 (args(1).scalar_value());
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4404 octave_idx_type n = static_cast<octave_idx_type>
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4405 (args(2).scalar_value());
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4406 if (!error_state)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4407 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4408 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4409 retval = retval.resize (dim_vector (m, n), true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4410 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4411 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4412 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4413 print_usage ();
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4414 return retval;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4415 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4416
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4417 // FIXME -- should use octave_idx_type for dimensions.
5734 a7d2c47371d2 [project @ 2006-04-04 18:29:13 by jwe] jwe parents: 5731 diff changeset	4418
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4419 DEFUN (reshape, args, ,
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4420 "-- texinfo --\n\
6671 9042b00fc45e [project @ 2007-05-30 06:33:29 by jwe] jwe parents: 6630 diff changeset	4421 @deftypefn {Built-in Function} {} reshape (@var{a}, @var{m}, @var{n}, @dots{})\n\
9042b00fc45e [project @ 2007-05-30 06:33:29 by jwe] jwe parents: 6630 diff changeset	4422 @deftypefnx {Built-in Function} {} reshape (@var{a}, @var{siz})\n\
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4423 Return a matrix with the given dimensions whose elements are taken\n\
6671 9042b00fc45e [project @ 2007-05-30 06:33:29 by jwe] jwe parents: 6630 diff changeset	4424 from the matrix @var{a}. The elements of the matrix are accessed in\n\
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4425 column-major order (like Fortran arrays are stored).\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4426 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4427 For example,\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4428 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4429 @example\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4430 @group\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4431 reshape ([1, 2, 3, 4], 2, 2)\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4432 @result{} 1 3\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4433 2 4\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4434 @end group\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4435 @end example\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4436 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4437 @noindent\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4438 Note that the total number of elements in the original\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4439 matrix must match the total number of elements in the new matrix.\n\
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4440 \n\
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4441 A single dimension of the return matrix can be unknown and is flagged\n\
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4442 by an empty argument.\n\
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4443 @end deftypefn")
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4444 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4445 octave_value retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4446
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4447 int nargin = args.length ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4448
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4449 Array<int> new_size;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4450
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4451 if (nargin == 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4452 new_size = args(1).int_vector_value ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4453 else if (nargin > 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4454 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4455 new_size.resize (nargin-1);
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4456 int empty_dim = -1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4457
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4458 for (int i = 1; i < nargin; i++)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4459 {
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4460 if (args(i).is_empty ())
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4461 if (empty_dim > 0)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4462 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4463 error ("reshape: only a single dimension can be unknown");
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4464 break;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4465 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4466 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4467 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4468 empty_dim = i;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4469 new_size(i-1) = 1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4470 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4471 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4472 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4473 new_size(i-1) = args(i).idx_type_value ();
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4474
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4475 if (error_state)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4476 break;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4477 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4478 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4479
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4480 if (! error_state && (empty_dim > 0))
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4481 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4482 int nel = 1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4483 for (int i = 0; i < nargin - 1; i++)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4484 nel *= new_size(i);
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4485
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4486 if (nel == 0)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4487 new_size(empty_dim-1) = 0;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4488 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4489 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4490 int size_empty_dim = args(0).numel () / nel;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4491
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4492 if (args(0).numel () != size_empty_dim * nel)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4493 error ("reshape: size is not divisble by the product of known dimensions (= %d)", nel);
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4494 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4495 new_size(empty_dim-1) = size_empty_dim;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4496 }
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4497 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4498 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4499 else
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4500 {
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4501 print_usage ();
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4502 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4503 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4504
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4505 if (error_state)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4506 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4507 error ("reshape: invalid arguments");
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4508 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4509 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4510
4739 7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4511 // Remove trailing singletons in new_size, but leave at least 2
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4512 // elements.
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4513
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4514 int n = new_size.length ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4515
4739 7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4516 while (n > 2)
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4517 {
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4518 if (new_size(n-1) == 1)
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4519 n--;
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4520 else
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4521 break;
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4522 }
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4523
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4524 new_size.resize (n);
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4525
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4526 if (n < 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4527 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4528 error ("reshape: expecting size to be vector with at least 2 elements");
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4529 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4530 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4531
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4532 dim_vector new_dims;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4533
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4534 new_dims.resize (n);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4535
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4536 for (octave_idx_type i = 0; i < n; i++)
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4537 new_dims(i) = new_size(i);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4538
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4539 octave_value arg = args(0);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4540
8526 17e0ad741fac reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8517 diff changeset	4541 dim_vector dims = arg.dims ();
17e0ad741fac reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8517 diff changeset	4542
17e0ad741fac reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8517 diff changeset	4543 if (new_dims.numel () == dims.numel ())
17e0ad741fac reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8517 diff changeset	4544 retval = (new_dims == dims) ? arg : arg.reshape (new_dims);
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4545 else
8527 6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4546 {
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4547 std::string dims_str = dims.str ();
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4548 std::string new_dims_str = new_dims.str ();
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4549
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4550 error ("reshape: can't reshape %s array to %s array",
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4551 dims_str.c_str (), new_dims_str.c_str ());
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4552 }
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4553
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4554 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4555 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4556
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4557 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4558
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4559 %!assert(size (reshape (ones (4, 4), 2, 8)), [2, 8])
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4560 %!assert(size (reshape (ones (4, 4), 8, 2)), [8, 2])
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4561 %!assert(size (reshape (ones (15, 4), 1, 60)), [1, 60])
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4562 %!assert(size (reshape (ones (15, 4), 60, 1)), [60, 1])
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4563
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4564 %!assert(size (reshape (ones (4, 4, 'single'), 2, 8)), [2, 8])
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4565 %!assert(size (reshape (ones (4, 4, 'single'), 8, 2)), [8, 2])
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4566 %!assert(size (reshape (ones (15, 4, 'single'), 1, 60)), [1, 60])
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4567 %!assert(size (reshape (ones (15, 4, 'single'), 60, 1)), [60, 1])
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4568
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4569 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4570 %! s.a = 1;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4571 %! fail("reshape (s, 2, 3)");
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4572
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4573 %!error <Invalid call to reshape.*> reshape ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4574 %!error reshape (1, 2, 3, 4);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4575
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4576 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4577
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4578 DEFUN (squeeze, args, ,
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4579 "-- texinfo --\n\
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4580 @deftypefn {Built-in Function} {} squeeze (@var{x})\n\
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4581 Remove singleton dimensions from @var{x} and return the result.\n\
6999 9325d3f604a3 [project @ 2007-10-10 17:03:34 by jwe] jwe parents: 6979 diff changeset	4582 Note that for compatibility with @sc{Matlab}, all objects have\n\
7007 6304d9ea0a30 [project @ 2007-10-11 16:26:36 by jwe] jwe parents: 7001 diff changeset	4583 a minimum of two dimensions and row vectors are left unchanged.\n\
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4584 @end deftypefn")
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4585 {
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4586 octave_value retval;
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4587
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4588 if (args.length () == 1)
4545 c16f153836a0 [project @ 2003-10-24 04:45:45 by jwe] jwe parents: 4532 diff changeset	4589 retval = args(0).squeeze ();
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4590 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4591 print_usage ();
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4592
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4593 return retval;
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4594 }
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4595
8458 d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4596 DEFUN (full, args, ,
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4597 "-- texinfo --\n\
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4598 @deftypefn {Loadable Function} {@var{FM} =} full (@var{SM})\n\
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4599 returns a full storage matrix from a sparse, diagonal, permutation matrix or a range.\n\
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4600 @seealso{sparse}\n\
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4601 @end deftypefn")
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4602 {
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4603 octave_value retval;
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4604
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4605 if (args.length () == 1)
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4606 retval = args(0).full_value ();
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4607 else
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4608 print_usage ();
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4609
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4610 return retval;
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4611 }
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4612
6945 6bbf56a9718a [project @ 2007-10-02 20:47:22 by jwe] jwe parents: 6887 diff changeset	4613 // Compute various norms of the vector X.
6bbf56a9718a [project @ 2007-10-02 20:47:22 by jwe] jwe parents: 6887 diff changeset	4614
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4615 DEFUN (norm, args, ,
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4616 "-- texinfo --\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4617 @deftypefn {Function File} {} norm (@var{a}, @var{p}, @var{opt})\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4618 Compute the p-norm of the matrix @var{a}. If the second argument is\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4619 missing, @code{p = 2} is assumed.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4620 \n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4621 If @var{a} is a matrix (or sparse matrix):\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4622 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4623 @table @asis\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4624 @item @var{p} = @code{1}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4625 1-norm, the largest column sum of the absolute values of @var{a}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4626 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4627 @item @var{p} = @code{2}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4628 Largest singular value of @var{a}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4629 \n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4630 @item @var{p} = @code{Inf} or @code{\"inf\"}\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4631 @cindex infinity norm\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4632 Infinity norm, the largest row sum of the absolute values of @var{a}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4633 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4634 @item @var{p} = @code{\"fro\"}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4635 @cindex Frobenius norm\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4636 Frobenius norm of @var{a}, @code{sqrt (sum (diag (@var{a}' * @var{a})))}.\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4637 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4638 @item other @var{p}, @code{@var{p} > 1}\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4639 @cindex general p-norm \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4640 maximum @code{norm (A*x, p)} such that @code{norm (x, p) == 1}\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4641 @end table\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4642 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4643 If @var{a} is a vector or a scalar:\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4644 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4645 @table @asis\n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4646 @item @var{p} = @code{Inf} or @code{\"inf\"}\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4647 @code{max (abs (@var{a}))}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4648 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4649 @item @var{p} = @code{-Inf}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4650 @code{min (abs (@var{a}))}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4651 \n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4652 @item @var{p} = @code{\"fro\"}\n\
e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4653 Frobenius norm of @var{a}, @code{sqrt (sumsq (abs (a)))}.\n\
e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4654 \n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4655 @item @var{p} = 0\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4656 Hamming norm - the number of nonzero elements.\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4657 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4658 @item other @var{p}, @code{@var{p} > 1}\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4659 p-norm of @var{a}, @code{(sum (abs (@var{a}) .^ @var{p})) ^ (1/@var{p})}.\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4660 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4661 @item other @var{p} @code{@var{p} < 1}\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4662 the p-pseudonorm defined as above.\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4663 @end table\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4664 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4665 If @code{\"rows\"} is given as @var{opt}, the norms of all rows of the matrix @var{a} are\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4666 returned as a column vector. Similarly, if @code{\"columns\"} or @code{\"cols\"} is passed\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4667 column norms are computed.\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4668 @seealso{cond, svd}\n\
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4669 @end deftypefn")
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4670 {
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4671 octave_value_list retval;
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4672
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4673 int nargin = args.length ();
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4674
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4675 if (nargin >= 1 && nargin <= 3)
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4676 {
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4677 octave_value x_arg = args(0);
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4678
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4679 if (x_arg.is_empty ())
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4680 {
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4681 if (x_arg.is_single_type ())
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4682 retval(0) = static_cast<float>(0.0);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4683 else
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4684 retval(0) = 0.0;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4685 }
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4686 else if (x_arg.ndims () == 2)
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4687 {
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4688 enum { sfmatrix, sfcols, sfrows, sffrob, sfinf } strflag = sfmatrix;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4689 if (nargin > 1 && args(nargin-1).is_string ())
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4690 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4691 std::string str = args(nargin-1).string_value ();
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4692 if (str == "cols" \|\| str == "columns")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4693 strflag = sfcols;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4694 else if (str == "rows")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4695 strflag = sfrows;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4696 else if (str == "fro")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4697 strflag = sffrob;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4698 else if (str == "inf")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4699 strflag = sfinf;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4700 else
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4701 error ("norm: unrecognized option: %s", str.c_str ());
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4702 // we've handled the last parameter, so act as if it was removed
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4703 nargin --;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4704 }
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4705 else if (nargin > 1 && ! args(1).is_scalar_type ())
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4706 gripe_wrong_type_arg ("norm", args(1), true);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4707
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4708 if (! error_state)
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4709 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4710 octave_value p_arg = (nargin > 1) ? args(1) : octave_value (2);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4711 switch (strflag)
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4712 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4713 case sfmatrix:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4714 retval(0) = xnorm (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4715 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4716 case sfcols:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4717 retval(0) = xcolnorms (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4718 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4719 case sfrows:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4720 retval(0) = xrownorms (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4721 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4722 case sffrob:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4723 retval(0) = xfrobnorm (x_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4724 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4725 case sfinf:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4726 retval(0) = xnorm (x_arg, octave_Inf);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4727 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4728 }
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4729 }
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4730 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4731 else
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4732 error ("norm: only valid for 2-D objects");
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4733 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4734 else
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4735 print_usage ();
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4736
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4737 return retval;
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4738 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4739
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4740 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4741 %!shared x
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4742 %! x = [1, -3, 4, 5, -7];
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4743 %!assert(norm(x,1), 20);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4744 %!assert(norm(x,2), 10);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4745 %!assert(norm(x,3), 8.24257059961711, -4*eps);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4746 %!assert(norm(x,Inf), 7);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4747 %!assert(norm(x,-Inf), 1);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4748 %!assert(norm(x,"inf"), 7);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4749 %!assert(norm(x,"fro"), 10, -eps);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4750 %!assert(norm(x), 10);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4751 %!assert(norm([1e200, 1]), 1e200);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4752 %!assert(norm([3+4i, 3-4i, sqrt(31)]), 9, -4*eps);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4753 %!shared m
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4754 %! m = magic (4);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4755 %!assert(norm(m,1), 34);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4756 %!assert(norm(m,2), 34, -eps);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4757 %!assert(norm(m,Inf), 34);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4758 %!assert(norm(m,"inf"), 34);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4759 %!shared m2, flo, fhi
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4760 %! m2 = [1,2;3,4];
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4761 %! flo = 1e-300;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4762 %! fhi = 1e+300;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4763 %!assert (norm(flom2,"fro"), sqrt(30)flo, -eps)
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4764 %!assert (norm(fhim2,"fro"), sqrt(30)fhi, -eps)
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4765
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4766 %!shared x
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4767 %! x = single([1, -3, 4, 5, -7]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4768 %!assert(norm(x,1), single(20));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4769 %!assert(norm(x,2), single(10));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4770 %!assert(norm(x,3), single(8.24257059961711), -4*eps('single'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4771 %!assert(norm(x,Inf), single(7));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4772 %!assert(norm(x,-Inf), single(1));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4773 %!assert(norm(x,"inf"), single(7));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4774 %!assert(norm(x,"fro"), single(10), -eps('single'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4775 %!assert(norm(x), single(10));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4776 %!assert(norm(single([1e200, 1])), single(1e200));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4777 %!assert(norm(single([3+4i, 3-4i, sqrt(31)])), single(9), -4*eps('single'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4778 %!shared m
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4779 %! m = single(magic (4));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4780 %!assert(norm(m,1), single(34));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4781 %!assert(norm(m,2), single(34), -eps('single'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4782 %!assert(norm(m,Inf), single(34));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4783 %!assert(norm(m,"inf"), single(34));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4784 %!shared m2, flo, fhi
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4785 %! m2 = single([1,2;3,4]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4786 %! flo = single(1e-300);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4787 %! fhi = single(1e+300);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4788 %!assert (norm(flom2,"fro"), single(sqrt(30)flo), -eps('single'))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4789 %!assert (norm(fhim2,"fro"), single(sqrt(30)fhi), -eps('single'))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4790 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4791
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4792 #define UNARY_OP_DEFUN_BODY(F) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4793 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4794 octave_value retval; \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4795 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4796 if (args.length () == 1) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4797 retval = F (args(0)); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4798 else \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4799 print_usage (); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4800 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4801 return retval
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4802
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4803 DEFUN (not, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4804 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4805 @deftypefn {Built-in Function} {} not (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4806 This function is equivalent to @code{! x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4807 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4808 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4809 UNARY_OP_DEFUN_BODY (op_not);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4810 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4811
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4812 DEFUN (uplus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4813 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4814 @deftypefn {Built-in Function} {} uplus (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4815 This function is equivalent to @code{+ x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4816 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4817 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4818 UNARY_OP_DEFUN_BODY (op_uplus);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4819 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4820
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4821 DEFUN (uminus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4822 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4823 @deftypefn {Built-in Function} {} uminus (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4824 This function is equivalent to @code{- x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4825 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4826 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4827 UNARY_OP_DEFUN_BODY (op_uminus);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4828 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4829
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4830 DEFUN (transpose, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4831 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4832 @deftypefn {Built-in Function} {} transpose (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4833 This function is equivalent to @code{x.'}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4834 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4835 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4836 UNARY_OP_DEFUN_BODY (op_transpose);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4837 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4838
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4839 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4840
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4841 %!assert (2.', 2);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4842 %!assert (2i.',2i);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4843 %!assert ([1:4].',[1;2;3;4]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4844 %!assert ([1;2;3;4].',[1:4]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4845 %!assert ([1,2;3,4].',[1,3;2,4]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4846 %!assert ([1,2i;3,4].',[1,3;2i,4]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4847
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4848 %!assert (transpose ([1,2;3,4]),[1,3;2,4]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4849
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4850 %!assert (single(2).', single(2));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4851 %!assert (single(2i).',single(2i));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4852 %!assert (single([1:4]).',single([1;2;3;4]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4853 %!assert (single([1;2;3;4]).',single([1:4]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4854 %!assert (single([1,2;3,4]).',single([1,3;2,4]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4855 %!assert (single([1,2i;3,4]).',single([1,3;2i,4]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4856
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4857 %!assert (transpose (single([1,2;3,4])),single([1,3;2,4]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4858
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4859 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4860
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4861 DEFUN (ctranspose, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4862 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4863 @deftypefn {Built-in Function} {} ctranspose (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4864 This function is equivalent to @code{x'}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4865 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4866 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4867 UNARY_OP_DEFUN_BODY (op_hermitian);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4868 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4869
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4870 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4871
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4872 %!assert (2', 2);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4873 %!assert (2i',-2i);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4874 %!assert ([1:4]',[1;2;3;4]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4875 %!assert ([1;2;3;4]',[1:4]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4876 %!assert ([1,2;3,4]',[1,3;2,4]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4877 %!assert ([1,2i;3,4]',[1,3;-2i,4]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4878
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4879 %!assert (ctranspose ([1,2i;3,4]),[1,3;-2i,4]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4880
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4881 %!assert (single(2)', single(2));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4882 %!assert (single(2i)',single(-2i));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4883 %!assert (single([1:4])',single([1;2;3;4]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4884 %!assert (single([1;2;3;4])',single([1:4]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4885 %!assert (single([1,2;3,4])',single([1,3;2,4]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4886 %!assert (single([1,2i;3,4])',single([1,3;-2i,4]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4887
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4888 %!assert (ctranspose (single([1,2i;3,4])),single([1,3;-2i,4]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4889
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4890 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4891
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4892 #define BINARY_OP_DEFUN_BODY(F) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4893 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4894 octave_value retval; \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4895 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4896 if (args.length () == 2) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4897 retval = F (args(0), args(1)); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4898 else \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4899 print_usage (); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4900 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4901 return retval
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4902
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4903 DEFUN (plus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4904 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4905 @deftypefn {Built-in Function} {} plus (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4906 This function is equivalent to @code{x + y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4907 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4908 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4909 BINARY_OP_DEFUN_BODY (op_add);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4910 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4911
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4912 DEFUN (minus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4913 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4914 @deftypefn {Built-in Function} {} minus (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4915 This function is equivalent to @code{x - y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4916 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4917 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4918 BINARY_OP_DEFUN_BODY (op_sub);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4919 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4920
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4921 DEFUN (mtimes, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4922 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4923 @deftypefn {Built-in Function} {} mtimes (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4924 This function is equivalent to @code{x * y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4925 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4926 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4927 BINARY_OP_DEFUN_BODY (op_mul);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4928 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4929
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4930 DEFUN (mrdivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4931 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4932 @deftypefn {Built-in Function} {} mrdivide (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4933 This function is equivalent to @code{x / y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4934 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4935 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4936 BINARY_OP_DEFUN_BODY (op_div);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4937 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4938
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4939 DEFUN (mpower, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4940 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4941 @deftypefn {Built-in Function} {} mpower (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4942 This function is equivalent to @code{x ^ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4943 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4944 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4945 BINARY_OP_DEFUN_BODY (op_pow);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4946 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4947
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4948 DEFUN (mldivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4949 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4950 @deftypefn {Built-in Function} {} mldivide (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4951 This function is equivalent to @code{x \\ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4952 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4953 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4954 BINARY_OP_DEFUN_BODY (op_ldiv);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4955 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4956
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4957 DEFUN (lt, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4958 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4959 @deftypefn {Built-in Function} {} lt (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4960 This function is equivalent to @code{x < y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4961 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4962 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4963 BINARY_OP_DEFUN_BODY (op_lt);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4964 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4965
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4966 DEFUN (le, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4967 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4968 @deftypefn {Built-in Function} {} le (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4969 This function is equivalent to @code{x <= y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4970 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4971 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4972 BINARY_OP_DEFUN_BODY (op_le);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4973 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4974
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4975 DEFUN (eq, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4976 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4977 @deftypefn {Built-in Function} {} eq (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4978 This function is equivalent to @code{x == y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4979 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4980 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4981 BINARY_OP_DEFUN_BODY (op_eq);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4982 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4983
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4984 DEFUN (ge, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4985 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4986 @deftypefn {Built-in Function} {} ge (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4987 This function is equivalent to @code{x >= y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4988 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4989 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4990 BINARY_OP_DEFUN_BODY (op_ge);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4991 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4992
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4993 DEFUN (gt, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4994 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4995 @deftypefn {Built-in Function} {} gt (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4996 This function is equivalent to @code{x > y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4997 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4998 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4999 BINARY_OP_DEFUN_BODY (op_gt);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5000 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5001
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5002 DEFUN (ne, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5003 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5004 @deftypefn {Built-in Function} {} ne (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5005 This function is equivalent to @code{x != y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5006 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5007 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5008 BINARY_OP_DEFUN_BODY (op_ne);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5009 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5010
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5011 DEFUN (times, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5012 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5013 @deftypefn {Built-in Function} {} times (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5014 This function is equivalent to @code{x .* y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5015 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5016 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5017 BINARY_OP_DEFUN_BODY (op_el_mul);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5018 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5019
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5020 DEFUN (rdivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5021 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5022 @deftypefn {Built-in Function} {} rdivide (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5023 This function is equivalent to @code{x ./ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5024 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5025 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5026 BINARY_OP_DEFUN_BODY (op_el_div);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5027 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5028
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5029 DEFUN (power, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5030 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5031 @deftypefn {Built-in Function} {} power (@var{x}, @var{y})\n\
7623 431f3788f5c4 minor doc patch David Bateman <dbateman@free.fr> parents: 7620 diff changeset	5032 This function is equivalent to @code{x .^ y}.\n\
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5033 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5034 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5035 BINARY_OP_DEFUN_BODY (op_el_pow);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5036 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5037
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5038 DEFUN (ldivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5039 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5040 @deftypefn {Built-in Function} {} ldivide (@var{x}, @var{y})\n\
7623 431f3788f5c4 minor doc patch David Bateman <dbateman@free.fr> parents: 7620 diff changeset	5041 This function is equivalent to @code{x .\\ y}.\n\
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5042 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5043 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5044 BINARY_OP_DEFUN_BODY (op_el_ldiv);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5045 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5046
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5047 DEFUN (and, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5048 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5049 @deftypefn {Built-in Function} {} and (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5050 This function is equivalent to @code{x & y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5051 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5052 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5053 BINARY_OP_DEFUN_BODY (op_el_and);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5054 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5055
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5056 DEFUN (or, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5057 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5058 @deftypefn {Built-in Function} {} or (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5059 This function is equivalent to @code{x \| y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5060 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5061 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5062 BINARY_OP_DEFUN_BODY (op_el_or);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5063 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5064
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5065 static double tic_toc_timestamp = -1.0;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5066
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5067 DEFUN (tic, args, nargout,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5068 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5069 @deftypefn {Built-in Function} {} tic ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5070 @deftypefnx {Built-in Function} {} toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5071 Set or check a wall-clock timer. Calling @code{tic} without an\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5072 output argument sets the timer. Subsequent calls to @code{toc}\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5073 return the number of seconds since the timer was set. For example,\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5074 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5075 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5076 tic ();\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5077 # many computations later...\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5078 elapsed_time = toc ();\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5079 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5080 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5081 @noindent\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5082 will set the variable @code{elapsed_time} to the number of seconds since\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5083 the most recent call to the function @code{tic}.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5084 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5085 If called with one output argument then this function returns a scalar\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5086 of type @code{uint64} and the wall-clock timer is not started.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5087 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5088 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5089 @group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5090 t = tic; sleep (5); (double (tic ()) - double (t)) * 1e-6\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5091 @result{} 5\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5092 @end group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5093 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5094 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5095 Nested timing with @code{tic} and @code{toc} is not supported.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5096 Therefore @code{toc} will always return the elapsed time from the most\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5097 recent call to @code{tic}.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5098 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5099 If you are more interested in the CPU time that your process used, you\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5100 should use the @code{cputime} function instead. The @code{tic} and\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5101 @code{toc} functions report the actual wall clock time that elapsed\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5102 between the calls. This may include time spent processing other jobs or\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5103 doing nothing at all. For example,\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5104 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5105 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5106 @group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5107 tic (); sleep (5); toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5108 @result{} 5\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5109 t = cputime (); sleep (5); cputime () - t\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5110 @result{} 0\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5111 @end group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5112 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5113 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5114 @noindent\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5115 (This example also illustrates that the CPU timer may have a fairly\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5116 coarse resolution.)\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5117 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5118 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5119 octave_value retval;
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5120
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5121 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5122
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5123 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5124 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5125
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5126 octave_time now;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5127
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5128 double tmp = now.double_value ();
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5129
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5130 if (nargout > 0)
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5131 retval = static_cast<octave_uint64> (1e6 * tmp);
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5132 else
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5133 tic_toc_timestamp = tmp;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5134
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5135 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5136 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5137
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5138 DEFUN (toc, args, nargout,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5139 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5140 @deftypefn {Built-in Function} {} toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5141 See tic.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5142 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5143 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5144 octave_value retval;
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5145
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5146 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5147
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5148 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5149 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5150
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5151 if (tic_toc_timestamp < 0)
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5152 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5153 warning ("toc called before timer set");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5154 if (nargout > 0)
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5155 retval = Matrix ();
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5156 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5157 else
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5158 {
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5159 octave_time now;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5160
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5161 double tmp = now.double_value () - tic_toc_timestamp;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5162
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5163 if (nargout > 0)
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5164 retval = tmp;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5165 else
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5166 octave_stdout << "Elapsed time is " << tmp << " seconds.\n";
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5167 }
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5168
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5169 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5170 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5171
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5172 DEFUN (cputime, args, ,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5173 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5174 @deftypefn {Built-in Function} {[@var{total}, @var{user}, @var{system}] =} cputime ();\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5175 Return the CPU time used by your Octave session. The first output is\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5176 the total time spent executing your process and is equal to the sum of\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5177 second and third outputs, which are the number of CPU seconds spent\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5178 executing in user mode and the number of CPU seconds spent executing in\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5179 system mode, respectively. If your system does not have a way to report\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5180 CPU time usage, @code{cputime} returns 0 for each of its output values.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5181 Note that because Octave used some CPU time to start, it is reasonable\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5182 to check to see if @code{cputime} works by checking to see if the total\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5183 CPU time used is nonzero.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5184 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5185 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5186 octave_value_list retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5187 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5188 double usr = 0.0;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5189 double sys = 0.0;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5190
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5191 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5192 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5193
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5194 #if defined (HAVE_GETRUSAGE)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5195
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5196 struct rusage ru;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5197
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5198 getrusage (RUSAGE_SELF, &ru);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5199
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5200 usr = static_cast<double> (ru.ru_utime.tv_sec) +
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5201 static_cast<double> (ru.ru_utime.tv_usec) * 1e-6;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5202
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5203 sys = static_cast<double> (ru.ru_stime.tv_sec) +
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5204 static_cast<double> (ru.ru_stime.tv_usec) * 1e-6;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5205
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5206 #elif defined (HAVE_TIMES) && defined (HAVE_SYS_TIMES_H)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5207
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5208 struct tms t;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5209
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5210 times (&t);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5211
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5212 unsigned long ticks;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5213 unsigned long seconds;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5214 unsigned long fraction;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5215
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5216 ticks = t.tms_utime + t.tms_cutime;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5217 fraction = ticks % HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5218 seconds = ticks / HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5219
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5220 usr = static_cast<double> (seconds) + static_cast<double>(fraction) /
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5221 static_cast<double>(HZ);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5222
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5223 ticks = t.tms_stime + t.tms_cstime;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5224 fraction = ticks % HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5225 seconds = ticks / HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5226
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5227 sys = static_cast<double> (seconds) + static_cast<double>(fraction) /
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5228 static_cast<double>(HZ);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5229
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5230 #elif defined (__WIN32__)
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5231
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5232 HANDLE hProcess = GetCurrentProcess ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5233 FILETIME ftCreation, ftExit, ftUser, ftKernel;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5234 GetProcessTimes (hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5235
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5236 int64_t itmp = (reinterpret_cast<int64_t > (&ftUser));
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5237 usr = static_cast<double> (itmp) * 1e-7;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5238
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5239 itmp = (reinterpret_cast<int64_t > (&ftKernel));
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5240 sys = static_cast<double> (itmp) * 1e-7;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5241
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5242 #endif
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5243
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5244 retval (2) = sys;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5245 retval (1) = usr;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5246 retval (0) = sys + usr;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5247
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5248 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5249 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5250
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5251 DEFUN (sort, args, nargout,
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5252 "-- texinfo --\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5253 @deftypefn {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x})\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5254 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{dim})\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5255 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{mode})\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5256 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{dim}, @var{mode})\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5257 Return a copy of @var{x} with the elements arranged in increasing\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5258 order. For matrices, @code{sort} orders the elements in each column.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5259 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5260 For example,\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5261 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5262 @example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5263 @group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5264 sort ([1, 2; 2, 3; 3, 1])\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5265 @result{} 1 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5266 2 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5267 3 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5268 @end group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5269 @end example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5270 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5271 The @code{sort} function may also be used to produce a matrix\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5272 containing the original row indices of the elements in the sorted\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5273 matrix. For example,\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5274 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5275 @example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5276 @group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5277 [s, i] = sort ([1, 2; 2, 3; 3, 1])\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5278 @result{} s = 1 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5279 2 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5280 3 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5281 @result{} i = 1 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5282 2 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5283 3 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5284 @end group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5285 @end example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5286 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5287 If the optional argument @var{dim} is given, then the matrix is sorted\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5288 along the dimension defined by @var{dim}. The optional argument @code{mode}\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5289 defines the order in which the values will be sorted. Valid values of\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5290 @code{mode} are `ascend' or `descend'.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5291 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5292 For equal elements, the indices are such that the equal elements are listed\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5293 in the order that appeared in the original list.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5294 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5295 The @code{sort} function may also be used to sort strings and cell arrays\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5296 of strings, in which case the dictionary order of the strings is used.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5297 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5298 The algorithm used in @code{sort} is optimized for the sorting of partially\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5299 ordered lists.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5300 @end deftypefn")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5301 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5302 octave_value_list retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5303
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5304 int nargin = args.length ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5305 sortmode smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5306
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5307 if (nargin < 1 \|\| nargin > 3)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5308 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5309 print_usage ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5310 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5311 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5312
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5313 bool return_idx = nargout > 1;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5314
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5315 octave_value arg = args(0);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5316
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5317 int dim = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5318 if (nargin > 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5319 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5320 if (args(1).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5321 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5322 std::string mode = args(1).string_value();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5323 if (mode == "ascend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5324 smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5325 else if (mode == "descend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5326 smode = DESCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5327 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5328 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5329 error ("sort: mode must be either \"ascend\" or \"descend\"");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5330 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5331 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5332 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5333 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5334 dim = args(1).nint_value () - 1;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5335 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5336
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5337 if (nargin > 2)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5338 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5339 if (args(1).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5340 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5341 print_usage ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5342 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5343 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5344
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5345 if (! args(2).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5346 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5347 error ("sort: mode must be a string");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5348 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5349 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5350 std::string mode = args(2).string_value();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5351 if (mode == "ascend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5352 smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5353 else if (mode == "descend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5354 smode = DESCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5355 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5356 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5357 error ("sort: mode must be either \"ascend\" or \"descend\"");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5358 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5359 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5360 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5361
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5362 dim_vector dv = arg.dims ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5363 if (error_state)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5364 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5365 gripe_wrong_type_arg ("sort", arg);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5366 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5367 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5368 if (nargin == 1 \|\| args(1).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5369 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5370 // Find first non singleton dimension
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5371 for (int i = 0; i < dv.length (); i++)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5372 if (dv(i) > 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5373 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5374 dim = i;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5375 break;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5376 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5377 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5378 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5379 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5380 if (dim < 0 \|\| dim > dv.length () - 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5381 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5382 error ("sort: dim must be a valid dimension");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5383 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5384 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5385 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5386
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5387 if (return_idx)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5388 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5389 Array<octave_idx_type> sidx;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5390
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5391 retval (0) = arg.sort (sidx, dim, smode);
7919 9d080df0c843 new NDArray constructor for ArrayN<octave_idx_type> David Bateman <dbateman@free.fr> parents: 7914 diff changeset	5392 retval (1) = NDArray (sidx, true);
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5393 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5394 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5395 retval(0) = arg.sort (dim, smode);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5396
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5397 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5398 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5399
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5400 /*
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5401
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5402 %% Double
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5403 %!assert (sort ([NaN, 1, -1, 2, Inf]), [-1, 1, 2, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5404 %!assert (sort ([NaN, 1, -1, 2, Inf], 1), [NaN, 1, -1, 2, Inf])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5405 %!assert (sort ([NaN, 1, -1, 2, Inf], 2), [-1, 1, 2, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5406 %!error (sort ([NaN, 1, -1, 2, Inf], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5407 %!assert (sort ([NaN, 1, -1, 2, Inf], "ascend"), [-1, 1, 2, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5408 %!assert (sort ([NaN, 1, -1, 2, Inf], 2, "ascend"), [-1, 1, 2, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5409 %!assert (sort ([NaN, 1, -1, 2, Inf], "descend"), [NaN, Inf, 2, 1, -1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5410 %!assert (sort ([NaN, 1, -1, 2, Inf], 2, "descend"), [NaN, Inf, 2, 1, -1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5411 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4]), [3, 1, 6, 4; 8, 2, 7, 5])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5412 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4], 1), [3, 1, 6, 4; 8, 2, 7, 5])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5413 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4], 2), [1, 3, 5, 7; 2, 4, 6, 8])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5414 %!assert (sort (1), 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5415
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5416 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5417 %! [v, i] = sort ([NaN, 1, -1, Inf, 1]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5418 %! assert (v, [-1, 1, 1, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5419 %! assert (i, [3, 2, 5, 4, 1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5420
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5421 %% Complex
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5422 %!assert (sort ([NaN, 1i, -1, 2, Inf]), [1i, -1, 2, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5423 %!assert (sort ([NaN, 1i, -1, 2, Inf], 1), [NaN, 1i, -1, 2, Inf])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5424 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2), [1i, -1, 2, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5425 %!error (sort ([NaN, 1i, -1, 2, Inf], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5426 %!assert (sort ([NaN, 1i, -1, 2, Inf], "ascend"), [1i, -1, 2, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5427 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2, "ascend"), [1i, -1, 2, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5428 %!assert (sort ([NaN, 1i, -1, 2, Inf], "descend"), [NaN, Inf, 2, -1, 1i])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5429 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2, "descend"), [NaN, Inf, 2, -1, 1i])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5430 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4]), [3, 1i, 6, 4; 8, 2, 7, 5])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5431 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4], 1), [3, 1i, 6, 4; 8, 2, 7, 5])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5432 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4], 2), [1i, 3, 5, 7; 2, 4, 6, 8])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5433 %!assert (sort (1i), 1i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5434
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5435 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5436 %! [v, i] = sort ([NaN, 1i, -1, Inf, 1, 1i]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5437 %! assert (v, [1, 1i, 1i, -1, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5438 %! assert (i, [5, 2, 6, 3, 4, 1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5439
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5440 %% Single
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5441 %!assert (sort (single([NaN, 1, -1, 2, Inf])), single([-1, 1, 2, Inf, NaN]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5442 %!assert (sort (single([NaN, 1, -1, 2, Inf]), 1), single([NaN, 1, -1, 2, Inf]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5443 %!assert (sort (single([NaN, 1, -1, 2, Inf]), 2), single([-1, 1, 2, Inf, NaN]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5444 %!error (sort (single([NaN, 1, -1, 2, Inf]), 3))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5445 %!assert (sort (single([NaN, 1, -1, 2, Inf]), "ascend"), single([-1, 1, 2, Inf, NaN]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5446 %!assert (sort (single([NaN, 1, -1, 2, Inf]), 2, "ascend"), single([-1, 1, 2, Inf, NaN]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5447 %!assert (sort (single([NaN, 1, -1, 2, Inf]), "descend"), single([NaN, Inf, 2, 1, -1]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5448 %!assert (sort (single([NaN, 1, -1, 2, Inf]), 2, "descend"), single([NaN, Inf, 2, 1, -1]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5449 %!assert (sort (single([3, 1, 7, 5; 8, 2, 6, 4])), single([3, 1, 6, 4; 8, 2, 7, 5]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5450 %!assert (sort (single([3, 1, 7, 5; 8, 2, 6, 4]), 1), single([3, 1, 6, 4; 8, 2, 7, 5]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5451 %!assert (sort (single([3, 1, 7, 5; 8, 2, 6, 4]), 2), single([1, 3, 5, 7; 2, 4, 6, 8]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5452 %!assert (sort (single(1)), single(1))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5453
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5454 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5455 %! [v, i] = sort (single([NaN, 1, -1, Inf, 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5456 %! assert (v, single([-1, 1, 1, Inf, NaN]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5457 %! assert (i, [3, 2, 5, 4, 1])
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5458
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5459 %% Single Complex
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5460 %!assert (sort (single([NaN, 1i, -1, 2, Inf])), single([1i, -1, 2, Inf, NaN]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5461 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), 1), single([NaN, 1i, -1, 2, Inf]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5462 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), 2), single([1i, -1, 2, Inf, NaN]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5463 %!error (sort (single([NaN, 1i, -1, 2, Inf]), 3))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5464 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), "ascend"), single([1i, -1, 2, Inf, NaN]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5465 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), 2, "ascend"), single([1i, -1, 2, Inf, NaN]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5466 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), "descend"), single([NaN, Inf, 2, -1, 1i]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5467 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), 2, "descend"), single([NaN, Inf, 2, -1, 1i]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5468 %!assert (sort (single([3, 1i, 7, 5; 8, 2, 6, 4])), single([3, 1i, 6, 4; 8, 2, 7, 5]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5469 %!assert (sort (single([3, 1i, 7, 5; 8, 2, 6, 4]), 1), single([3, 1i, 6, 4; 8, 2, 7, 5]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5470 %!assert (sort (single([3, 1i, 7, 5; 8, 2, 6, 4]), 2), single([1i, 3, 5, 7; 2, 4, 6, 8]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5471 %!assert (sort (single(1i)),single( 1i))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5472
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5473 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5474 %! [v, i] = sort (single([NaN, 1i, -1, Inf, 1, 1i]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5475 %! assert (v, single([1, 1i, 1i, -1, Inf, NaN]))
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5476 %! assert (i, [5, 2, 6, 3, 4, 1])
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5477
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5478 %% Bool
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5479 %!assert (sort ([true, false, true, false]), [false, false, true, true])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5480 %!assert (sort ([true, false, true, false], 1), [true, false, true, false])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5481 %!assert (sort ([true, false, true, false], 2), [false, false, true, true])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5482 %!error (sort ([true, false, true, false], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5483 %!assert (sort ([true, false, true, false], "ascend"), [false, false, true, true])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5484 %!assert (sort ([true, false, true, false], 2, "ascend"), [false, false, true, true])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5485 %!assert (sort ([true, false, true, false], "descend"), [true, true, false, false])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5486 %!assert (sort ([true, false, true, false], 2, "descend"), [true, true, false, false])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5487 %!assert (sort (true), true)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5488
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5489 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5490 %! [v, i] = sort ([true, false, true, false]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5491 %! assert (v, [false, false, true, true])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5492 %! assert (i, [2, 4, 1, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5493
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5494 %% Sparse Double
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5495 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf])), sparse ([-1, 0, 0, 1, 2, Inf, NaN]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5496 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 1), sparse ([0, NaN, 1, 0, -1, 2, Inf]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5497 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2), sparse ([-1, 0, 0, 1, 2, Inf, NaN]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5498 %!error (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5499 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), "ascend"), sparse ([-1, 0, 0, 1, 2, Inf, NaN]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5500 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2, "ascend"), sparse ([-1, 0, 0, 1, 2, Inf, NaN]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5501 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), "descend"), sparse ([NaN, Inf, 2, 1, 0, 0, -1]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5502 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2, "descend"), sparse ([NaN, Inf, 2, 1, 0, 0, -1]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5503
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5504 %!shared a
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5505 %! a = randn (10, 10);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5506 %! a (a < 0) = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5507 %!assert (sort (sparse (a)), sparse (sort (a)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5508 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5509 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5510 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5511 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5512 %! [vs, is] = sort (sparse (a));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5513 %! assert (vs, sparse (v))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5514 %! assert (is, i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5515
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5516 %% Sparse Complex
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5517 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf])), sparse ([0, 0, 1i, -1, 2, Inf, NaN]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5518 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 1), sparse ([0, NaN, 1i, 0, -1, 2, Inf]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5519 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2), sparse ([0, 0, 1i, -1, 2, Inf, NaN]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5520 %!error (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5521 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), "ascend"), sparse ([0, 0, 1i, -1, 2, Inf, NaN]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5522 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2, "ascend"), sparse ([0, 0, 1i, -1, 2, Inf, NaN]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5523 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), "descend"), sparse ([NaN, Inf, 2, -1, 1i, 0, 0]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5524 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2, "descend"), sparse ([NaN, Inf, 2, -1, 1i, 0, 0]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5525
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5526 %!shared a
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5527 %! a = randn (10, 10);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5528 %! a (a < 0) = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5529 %! a = 1i * a;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5530 %!assert (sort (sparse (a)), sparse (sort (a)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5531 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5532 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5533 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5534 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5535 %! [vs, is] = sort (sparse (a));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5536 %! assert (vs, sparse (v))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5537 %! assert (is, i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5538
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5539 %% Sparse Bool
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5540 %!assert (sort (sparse ([true, false, true, false])), sparse ([false, false, true, true]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5541 %!assert (sort (sparse([true, false, true, false]), 1), sparse ([true, false, true, false]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5542 %!assert (sort (sparse ([true, false, true, false]), 2), sparse ([false, false, true, true]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5543 %!error (sort (sparse ([true, false, true, false], 3)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5544 %!assert (sort (sparse ([true, false, true, false]), "ascend"), sparse([false, false, true, true]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5545 %!assert (sort (sparse ([true, false, true, false]), 2, "ascend"), sparse([false, false, true, true]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5546 %!assert (sort (sparse ([true, false, true, false]), "descend"), sparse ([true, true, false, false]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5547 %!assert (sort (sparse ([true, false, true, false]), 2, "descend"), sparse([true, true, false, false]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5548
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5549 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5550 %! [v, i] = sort (sparse([true, false, true, false]));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5551 %! assert (v, sparse([false, false, true, true]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5552 %! assert (i, [2, 4, 1, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5553
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5554 %% Cell string array
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5555 %!shared a, b, c
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5556 %! a = {"Alice", "Cecile", "Eric", "Barry", "David"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5557 %! b = {"Alice", "Barry", "Cecile", "David", "Eric"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5558 %! c = {"Eric", "David", "Cecile", "Barry", "Alice"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5559 %!assert (sort (a), b);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5560 %!assert (sort (a, 1), a)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5561 %!assert (sort (a, 2), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5562 %!error (sort (a, 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5563 %!assert (sort (a, "ascend"), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5564 %!assert (sort (a, 2, "ascend"), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5565 %!assert (sort (a, "descend"), c)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5566 %!assert (sort (a, 2, "descend"), c)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5567
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5568 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5569 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5570 %! assert (i, [1, 4, 2, 5, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5571
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5572 %!error <Invalid call to sort.*> sort ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5573 %!error <Invalid call to sort.*> sort (1, 2, 3, 4);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5574
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5575 */
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5576
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5577 DEFUN (__sort_rows_idx__, args, ,
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5578 "-- texinfo --\n\
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5579 @deftypefn {Function File} {} __sort_rows_idx__ (@var{a}, @var{mode})\n\
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5580 Sort the rows of the matrix @var{a} according to the order specified\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5581 by @var{mode}, which can either be `ascend' or `descend'.\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5582 Returns the index vector.\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5583 \n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5584 This function does not yet support sparse matrices.\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5585 @end deftypefn\n")
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5586 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5587 octave_value retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5588
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5589 int nargin = args.length ();
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5590 sortmode smode = ASCENDING;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5591
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5592 if (nargin < 1 \|\| nargin > 2 \|\| (nargin == 2 && ! args(1).is_string ()))
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5593 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5594 print_usage ();
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5595 return retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5596 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5597
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5598 if (nargin > 1)
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5599 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5600 std::string mode = args(1).string_value();
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5601 if (mode == "ascend")
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5602 smode = ASCENDING;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5603 else if (mode == "descend")
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5604 smode = DESCENDING;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5605 else
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5606 {
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5607 error ("__sort_rows_idx__: mode must be either \"ascend\" or \"descend\"");
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5608 return retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5609 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5610 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5611
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5612 octave_value arg = args(0);
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5613
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5614 if (arg.is_sparse_type ())
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5615 error ("__sort_rows_idx__: sparse matrices not yet supported");
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5616 if (arg.ndims () == 2)
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5617 {
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5618 Array<octave_idx_type> idx = arg.sort_rows_idx (smode);
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5619
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5620 retval = NDArray (idx, true);
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5621 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5622 else
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5623 error ("__sort_rows_idx__: needs a 2-dimensional object");
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5624
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5625 return retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5626 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5627
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5628 DEFUN (issorted, args, ,
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5629 "-- texinfo --\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5630 @deftypefn {Function File} {} issorted (@var{a}, @var{rows})\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5631 Returns true if the array is sorted, ascending or descending.\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5632 NaNs are treated is by @code{sort}. If @var{rows} is supplied and\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5633 has the value \"rows\", checks whether the array is sorted by rows\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5634 as if output by @code{sortrows} (with no options).\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5635 \n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5636 This function does not yet support sparse matrices.\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5637 @seealso{sortrows, sort}\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5638 @end deftypefn\n")
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5639 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5640 octave_value retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5641
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5642 int nargin = args.length ();
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5643
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5644 if (nargin == 1)
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5645 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5646 octave_value arg = args(0);
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5647 if (arg.dims ().is_vector ())
8734 767ed8cc6634 rename internal issorted and issorted_rows functions to is_sorted and is_sorted_rows John W. Eaton <jwe@octave.org> parents: 8733 diff changeset	5648 retval = args(0).is_sorted () != UNSORTED;
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5649 else
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5650 error ("issorted: needs a vector");
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5651 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5652 else if (nargin == 2)
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5653 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5654 if (args(1).is_string () && args(1).string_value () == "rows")
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5655 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5656 octave_value arg = args(0);
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5657 sortmode smode = ASCENDING;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5658
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5659 if (arg.is_sparse_type ())
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5660 error ("issorted: sparse matrices not yet supported");
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5661 if (arg.ndims () == 2)
8734 767ed8cc6634 rename internal issorted and issorted_rows functions to is_sorted and is_sorted_rows John W. Eaton <jwe@octave.org> parents: 8733 diff changeset	5662 retval = arg.is_sorted_rows (smode) != UNSORTED;
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5663 else
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5664 error ("issorted: needs a 2-dimensional object");
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5665 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5666 else
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5667 error ("issorted: second argument must be \"rows\"");
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5668 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5669 else
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5670 print_usage ();
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5671
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5672 return retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5673 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5674
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5675
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5676
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5677 /*
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5678 ;;; Local Variables: ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5679 ;;; mode: C++ ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5680 ;;; End: ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5681 */

Mercurial > octave-nkf

annotate src/data.cc @ 8734:767ed8cc6634