octave-lyh: src/data.cc annotate

annotate src/data.cc @ 8487:5701c2fe3327

[docs] 64 bit => 64-bit

author	Brian Gough <bjg@gnu.org>
date	Tue, 13 Jan 2009 00:26:40 -0500
parents	d17874a6f161
children	81d6ab3ac93c

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
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	6 This file is part of Octave.
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	7
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	8 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	9 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	10 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	11 option) any later version.
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	12
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	13 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	14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	15 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	16 for more details.
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	17
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	18 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	19 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	20 <http://www.gnu.org/licenses/>.
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	21
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 #ifdef HAVE_CONFIG_H
1192 b6360f2d4fa6 [project @ 1995-03-30 21:38:35 by jwe] jwe parents: 1129 diff changeset	25 #include <config.h>
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	26 #endif
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	27
7078 405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	28 #include "systime.h"
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	29
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	30 #ifdef HAVE_SYS_TYPES_H
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	31 #include <sys/types.h>
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	32 #endif
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	33
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	34 #ifdef HAVE_SYS_RESOURCE_H
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	35 #include <sys/resource.h>
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	36 #endif
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	37
2184 dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	38 #include <cfloat>
dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	39
1728 42b4f904f1af [project @ 1996-01-09 11:36:01 by jwe] jwe parents: 1572 diff changeset	40 #include <string>
42b4f904f1af [project @ 1996-01-09 11:36:01 by jwe] jwe parents: 1572 diff changeset	41
2184 dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	42 #include "lo-ieee.h"
7231 2eb392d058bb [project @ 2007-11-30 18:53:29 by jwe] jwe parents: 7189 diff changeset	43 #include "lo-math.h"
1755 3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe] jwe parents: 1742 diff changeset	44 #include "str-vec.h"
4153 6b96ce9f5743 [project @ 2002-11-06 20:38:49 by jwe] jwe parents: 4114 diff changeset	45 #include "quit.h"
1755 3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe] jwe parents: 1742 diff changeset	46
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	47 #include "Cell.h"
1352 19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	48 #include "defun.h"
19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	49 #include "error.h"
19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	50 #include "gripes.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	51 #include "oct-map.h"
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	52 #include "oct-obj.h"
2366 c90105b99479 [project @ 1996-10-11 23:22:27 by jwe] jwe parents: 2305 diff changeset	53 #include "ov.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	54 #include "ov-float.h"
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	55 #include "ov-complex.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	56 #include "ov-flt-complex.h"
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	57 #include "ov-cx-mat.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	58 #include "ov-flt-cx-mat.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	59 #include "ov-cx-sparse.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	60 #include "parse.h"
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	61 #include "pt-mat.h"
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	62 #include "utils.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	63 #include "variables.h"
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	64 #include "pager.h"
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	65 #include "xnorm.h"
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	66
7914 e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	67 #if ! defined (HAVE_HYPOTF) && defined (HAVE__HYPOTF)
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	68 #define hypotf _hypotf
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	69 #define HAVE_HYPOTF 1
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	70 #endif
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	71
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	72 #define ANY_ALL(FCN) \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	73 \
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	74 octave_value retval; \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	75 \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	76 int nargin = args.length (); \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	77 \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	78 if (nargin == 1 \|\| nargin == 2) \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	79 { \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	80 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	81 \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	82 if (! error_state) \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	83 { \
4556 773a21e4fce8 [project @ 2003-10-28 05:02:10 by jwe] jwe parents: 4554 diff changeset	84 if (dim >= -1) \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	85 retval = args(0).FCN (dim); \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	86 else \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	87 error (#FCN ": invalid dimension argument = %d", dim + 1); \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	88 } \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	89 else \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	90 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	91 } \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	92 else \
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	93 print_usage (); \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	94 \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	95 return retval
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	96
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	97 DEFUN (all, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	98 "-- texinfo --\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	99 @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	100 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	101 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	102 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	103 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	104 {
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	105 ANY_ALL (all);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	106 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	107
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	108 /*
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 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	111 %! 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	112 %! 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	113 %! 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	114 %! && 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	115 %! && 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	116 %! && 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	117
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	118 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	119 %! 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	120 %! 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	121 %! 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	122 %! && 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	123 %! && 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	124 %! && 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	125
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	126 %!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	127 %!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	128
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
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	131 DEFUN (any, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	132 "-- texinfo --\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	133 @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	134 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	135 nonzero.\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	136 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	137 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	138 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	139 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	140 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	141 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	142 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	143 any (eye (2, 4))\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	144 @result{} [ 1, 1, 0, 0 ]\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	145 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	146 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	147 \n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	148 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	149 @var{dim}. For example,\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	150 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	151 @example\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	152 @group\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	153 any (eye (2, 4), 2)\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	154 @result{} [ 1; 1 ]\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	155 @end group\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	156 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	157 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	158 {
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	159 ANY_ALL (any);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	160 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	161
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	162 /*
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 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	165 %! 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	166 %! 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	167 %! 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	168 %! && 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	169 %! && 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	170 %! && 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	171
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	172 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	173 %! 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	174 %! 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	175 %! 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	176 %! && 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	177 %! && 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	178 %! && 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	179
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	180 %!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	181 %!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	182
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
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	185 // 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	186
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	187 typedef double (*d_dd_fcn) (double, double);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	188 typedef float (*f_ff_fcn) (float, float);
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	189
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	190 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	191 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	192 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	193 NDArray retval (y.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	194 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	195
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	196 const double *y_data = y.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	197
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	198 octave_idx_type nel = y.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	199
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	200 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	201 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	202 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	203 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	204 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	205
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	206 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	207 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	208
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	209 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	210 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	211 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	212 FloatNDArray retval (y.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	213 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	214
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	215 const float *y_data = y.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	216
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	217 octave_idx_type nel = y.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	218
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	219 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	220 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	221 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	222 r_data[i] = f (x, y_data[i]);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	223 }
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 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	226 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	227
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	228 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	229 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	230 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	231 NDArray retval (x.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	232 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	233
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	234 const double *x_data = x.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	235
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	236 octave_idx_type nel = x.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	237
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	238 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	239 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	240 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	241 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	242 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	243
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	244 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	245 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	246
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	247 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	248 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	249 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	250 FloatNDArray retval (x.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	251 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	252
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	253 const float *x_data = x.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	254
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	255 octave_idx_type nel = x.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	256
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	257 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	258 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	259 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	260 r_data[i] = f (x_data[i], y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	261 }
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 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	264 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	265
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	266 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	267 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	268 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	269 assert (x.dims () == y.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	270
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	271 NDArray retval (x.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	272 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	273
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	274 const double *x_data = x.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	275 const double *y_data = y.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	276
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	277 octave_idx_type nel = x.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	278
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	279 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	280 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	281 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	282 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	283 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	284
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	285 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	286 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	287
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	288 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	289 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	290 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	291 assert (x.dims () == y.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	292
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	293 FloatNDArray retval (x.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	294 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	295
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	296 const float *x_data = x.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	297 const float *y_data = y.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	298
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	299 octave_idx_type nel = x.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	300
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	301 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	302 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	303 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	304 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	305 }
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 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	308 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	309
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	310 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	311 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	312 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	313 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	314 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	315 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	316 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	317
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	318 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	319 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	320 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	321
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	322 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	323 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	324 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	325 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	326 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	327 }
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 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	330 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	331 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	332 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	333 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	334 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	335 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	336 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	337
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	338 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	339 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	340 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	341 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	342 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	343 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	344
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	345 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	346 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	347 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	348 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	349 }
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 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	352 }
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 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	355 }
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 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	358 }
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 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	361 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	362 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	363 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	364 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	365 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	366 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	367
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	368 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	369 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	370 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	371
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	372 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	373 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	374 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	375 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	376 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	377 }
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 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	380 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	381 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	382 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	383 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	384 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	385 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	386 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	387
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	388 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	389 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	390 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	391 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	392 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	393 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	394
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	395 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	396 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	397 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	398 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	399 }
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 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	402 }
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 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	405 }
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 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	408 }
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 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	411 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	412 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	413 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	414 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	415
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	416 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	417 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	418
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	419 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	420
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	421 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	422 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	423
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	424 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	425 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	426 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	427 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	428
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	429 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	430 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	431 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	432 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	433 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	434 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	435 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	436 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	437 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 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	439 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	440 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	441 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	442 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	443 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	444 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	445 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	446 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	447 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	448
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	449 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	450 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	451 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	452 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	453 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	454 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	455 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	456 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	457 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 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	459 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	460 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	461 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	462 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	463 k2++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	464 }
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 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	470 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	471 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	472 {
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	473 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	474 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	475 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	476 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	477 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	478
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	479 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	480 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	481 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	482 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	483 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	484 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	485 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	486 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	487 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	488 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	489 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	490 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	491 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	492 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	493 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	494 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	495 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	496 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	497 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	498 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	499 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	500
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	501 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	502 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	503 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	504 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	505 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	506 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	507 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	508 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	509 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	510 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	511 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	512 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	513 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	514 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	515 }
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 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	518 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	519 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	520 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	521 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	522 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	523 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	524 }
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 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	527 }
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 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	530 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	531
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	532 DEFUN (atan2, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	533 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	534 @deftypefn {Mapping Function} {} atan2 (@var{y}, @var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	535 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	536 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	537 @end deftypefn")
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	538 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	539 octave_value retval;
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	540
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	541 int nargin = args.length ();
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	542
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	543 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	544 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	545 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	546 error ("atan2: not defined for integer types");
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	547 else
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	548 {
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	549 octave_value arg_y = args(0);
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	550 octave_value arg_x = args(1);
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	551
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	552 dim_vector y_dims = arg_y.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	553 dim_vector x_dims = arg_x.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	554
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	555 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	556 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	557
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	558 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	559
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	560 if (y_is_scalar && x_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	561 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	562 if (is_float)
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	563 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	564 float y = arg_y.float_value ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	565
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	566 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	567 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	568 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	569
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	570 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	571 retval = atan2f (y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	572 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	575 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	576 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	577
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	578 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	579 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	580 double x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	581
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	582 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	583 retval = atan2 (y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	584 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	585 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	586 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	587 else if (y_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	588 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	589 if (is_float)
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	590 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	591 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	592
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	593 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	594 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	595 // 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	596 FloatNDArray x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	597
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	598 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	599 retval = map_f_fm (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	600 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	603 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	604 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	605
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	606 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	607 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	608 // 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	609 NDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	610
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	611 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	612 retval = map_d_m (atan2, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	613 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	614 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	615 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	616 else if (x_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	617 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	618 if (arg_y.is_sparse_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	619 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	620 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	621
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	622 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	623 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	624 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	625
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	626 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	627 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	628 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	629 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	630 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	631 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	632 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	633
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	634 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	635 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	636 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	637
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	638 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	639 retval = map_fm_f (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	640 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	641 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	642 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	643 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	644 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	645
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	646 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	647 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	648 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	649
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	650 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	651 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	652 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	653 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	654 }
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	655 else if (y_dims == x_dims)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	656 {
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	657 // 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	658 if (arg_x.is_sparse_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	659 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	660 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	661
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	662 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	663 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	664 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	665
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	666 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	667 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	668 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	669 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	670 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	671 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	672 FloatNDArray y = arg_y.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	673
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	674 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	675 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	676 FloatNDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	677
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	678 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	679 retval = map_fm_fm (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	680 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	681 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	682 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	683 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	684 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	685
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	686 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	687 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	688 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	689
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	690 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	691 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	692 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	693 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	694 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	695 else
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	696 error ("atan2: nonconformant matrices");
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	697 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	698 }
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	699 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	700 print_usage ();
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	701
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	702 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	703 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	704
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	705 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	706 %!assert (size (atan2 (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	707 %!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	708 %!assert (size (atan2 (rand (2, 3, 4), 1)), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	709 %!assert (size (atan2 (1, rand (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	710 %!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	711
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	712 %!test
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	713 %! rt2 = sqrt (2);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	714 %! rt3 = sqrt (3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	715 %! 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	716 %! 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	717 %! 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	718 %! 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	719
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	720 %!test
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	721 %! rt2 = sqrt (2);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	722 %! rt3 = sqrt (3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	723 %! 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	724 %! 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	725 %! 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	726 %! 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	727
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	728 %!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	729 %!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	730
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	731 */
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	732
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	733
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	734
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	735 DEFUN (hypot, args, ,
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	736 "-- texinfo --\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	737 @deftypefn {Mapping Function} {} hypot (@var{x}, @var{y})\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	738 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	739 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	740 .^ 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	741 values of @var{x} or @var{y}.\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	742 @end deftypefn")
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	743 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	744 octave_value retval;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	745
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	746 int nargin = args.length ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	747
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	748 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	749 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	750 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	751 error ("hypot: not defined for integer types");
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	752 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	753 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	754 octave_value arg_x = args(0);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	755 octave_value arg_y = args(1);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	756
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	757 dim_vector x_dims = arg_x.dims ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	758 dim_vector y_dims = arg_y.dims ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	759
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	760 bool x_is_scalar = x_dims.all_ones ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	761 bool y_is_scalar = y_dims.all_ones ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	762
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	763 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	764
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	765 if (y_is_scalar && x_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	766 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	767 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	768 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	769 float x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	770 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	771 x = abs (arg_x.float_complex_value ());
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	772 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	773 x = arg_x.float_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	774
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	775 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	776 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	777 float y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	778 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	779 y = abs (arg_y.float_complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	780 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	781 y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	782
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	783 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	784 retval = hypotf (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	785 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	788 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	789 double x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	790 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	791 x = abs (arg_x.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	792 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	793 x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	794
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	795 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	796 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	797 double y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	798 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	799 y = abs (arg_y.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	800 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	801 y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	802
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	803 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	804 retval = hypot (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	805 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	806 }
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 else if (y_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	809 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	810 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	811 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	812 FloatNDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	813 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	814 x = arg_x.float_complex_array_value ().abs ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	815 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	816 x = arg_x.float_array_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	817
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	818 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	819 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	820 float y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	821 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	822 y = abs (arg_y.float_complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	823 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	824 y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	825
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	826 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	827 retval = map_fm_f (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	828 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	831 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	832 NDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	833 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	834 x = arg_x.complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	835 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	836 x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	837
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	838 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	839 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	840 double y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	841 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	842 y = abs (arg_y.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	843 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	844 y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	845
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	846 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	847 retval = map_m_d (hypot, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	848 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	849 }
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 else if (x_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	852 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	853 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	854 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	855 float x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	856 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	857 x = abs (arg_x.float_complex_value ());
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	858 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	859 x = arg_x.float_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	860
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	861 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	862 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	863 FloatNDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	864 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	865 y = arg_y.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	866 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	867 y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	868
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	869 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	870 retval = map_f_fm (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	871 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	874 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	875 double x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	876 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	877 x = abs (arg_x.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	878 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	879 x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	880
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	881 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	882 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	883 NDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	884 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	885 y = arg_y.complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	886 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	887 y = arg_y.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	888
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	889 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	890 retval = map_d_m (hypot, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	891 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	892 }
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 else if (y_dims == x_dims)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	895 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	896 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	897 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	898 SparseMatrix x;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	899 if (arg_x.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	900 x = arg_x.sparse_complex_matrix_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	901 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	902 x = arg_x.sparse_matrix_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	903
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	904 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	905 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	906 SparseMatrix y;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	907 if (arg_y.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	908 y = arg_y.sparse_complex_matrix_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	909 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	910 y = arg_y.sparse_matrix_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	911
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	912 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	913 retval = map_s_s (hypot, x, y);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	914 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	915 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	916 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	917 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	918 FloatNDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	919 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	920 x = arg_x.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	921 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	922 x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	923
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	924 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	925 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	926 FloatNDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	927 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	928 y = arg_y.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	929 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	930 y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	931
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	932 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	933 retval = map_fm_fm (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	934 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	935 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	936 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	937 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	938 NDArray x;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	939 if (arg_x.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	940 x = arg_x.complex_array_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	941 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	942 x = arg_x.array_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	943
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	944 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	945 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	946 NDArray y;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	947 if (arg_y.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	948 y = arg_y.complex_array_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	949 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	950 y = arg_y.array_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	951
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	952 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	953 retval = map_m_m (hypot, x, y);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	954 }
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 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	958 error ("hypot: nonconformant matrices");
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	959 }
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 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	962 print_usage ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	963
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	964 return retval;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	965 }
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 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	968 %!assert (size (hypot (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	969 %!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	970 %!assert (size (hypot (rand (2, 3, 4), 1)), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	971 %!assert (size (hypot (1, rand (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	972 %!assert (size (hypot (1, 2)), [1, 1])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	973 %!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	974 %!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	975 */
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	976
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	977 template<typename T, typename ET>
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	978 void
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	979 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	980 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	981 f = Array<T>(x.dims ());
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	982 e = Array<ET>(x.dims ());
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	983 for (octave_idx_type i = 0; i < x.numel (); i++)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	984 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	985 int exp;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	986 f.xelem (i) = xlog2 (x(i), exp);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	987 e.xelem (i) = exp;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	988 }
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 DEFUN (log2, args, nargout,
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	992 "-- texinfo --\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	993 @deftypefn {Mapping Function} {} log2 (@var{x})\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	994 @deftypefnx {Mapping Function} {[@var{f}, @var{e}] = } log2 (@var{x})\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	995 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	996 If called with two output arguments, split @var{x} to\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	997 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	998 @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	999 @seealso{log, log10, log2, exp}\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1000 @end deftypefn")
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1001 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1002 octave_value_list retval;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1003
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1004 if (args.length () == 1)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1005 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1006 if (nargout < 2)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1007 retval(0) = args(0).log2 ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1008 else if (args(0).is_single_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1009 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1010 if (args(0).is_real_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1011 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1012 FloatNDArray f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1013 FloatNDArray x = args(0).float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1014 // FIXME -- should E be an int value?
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1015 FloatMatrix e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1016 map_2_xlog2 (x, f, e);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1017 retval (1) = e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1018 retval (0) = f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1019 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1020 else if (args(0).is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1021 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1022 FloatComplexNDArray f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1023 FloatComplexNDArray x = args(0).float_complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1024 // FIXME -- should E be an int value?
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1025 FloatNDArray e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1026 map_2_xlog2 (x, f, e);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1027 retval (1) = e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1028 retval (0) = f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1029 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1030 }
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1031 else if (args(0).is_real_type ())
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1032 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1033 NDArray f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1034 NDArray x = args(0).array_value ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1035 // FIXME -- should E be an int value?
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1036 Matrix e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1037 map_2_xlog2 (x, f, e);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1038 retval (1) = e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1039 retval (0) = f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1040 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1041 else if (args(0).is_complex_type ())
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1042 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1043 ComplexNDArray f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1044 ComplexNDArray x = args(0).complex_array_value ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1045 // FIXME -- should E be an int value?
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1046 NDArray e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1047 map_2_xlog2 (x, f, e);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1048 retval (1) = e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1049 retval (0) = f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1050 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1051 else
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1052 gripe_wrong_type_arg ("log2", args(0));
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1053 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1054 else
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1055 print_usage ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1056
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1057 return retval;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1058 }
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 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1061 %!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	1062 %!assert(log2(Inf), Inf);
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1063 %!assert(isnan(log2(NaN)));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1064 %!assert(log2(4i), 2 + log2(1i));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1065 %!assert(log2(complex(0,Inf)), Inf + log2(i));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1066
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1067 %!test
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1068 %! [f, e] = log2 ([0,-1; 2,-4; Inf,-Inf]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1069 %! assert (f, [0,-0.5; 0.5,-0.5; Inf,-Inf]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1070 %! assert (e, [0,1;2,3;0,0])
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1071
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1072 %!test
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1073 %! [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	1074 %! 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	1075 %! assert (e, [0,1; 2,3; 0,0]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1076 */
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1077
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1078 DEFUN (fmod, args, ,
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1079 "-- texinfo --\n\
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1080 @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	1081 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	1082 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	1083 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	1084 @end deftypefn")
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1085 {
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1086 octave_value retval;
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1087
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1088 int nargin = args.length ();
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1089
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1090 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	1091 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1092 octave_value arg_y = args(0);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1093 octave_value arg_x = args(1);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1094
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1095 dim_vector y_dims = arg_y.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1096 dim_vector x_dims = arg_x.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1097
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1098 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	1099 bool x_is_scalar = x_dims.all_ones ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1100
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1101 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	1102
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1103 if (y_is_scalar && x_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1104 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1105 if (is_float)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1106 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1107 float y = arg_y.float_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1108
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1109 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1110 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1111 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1112
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1113 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1114 retval = fmod (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1115 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1118 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1119 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1120
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1121 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1122 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1123 double x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1124
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1125 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1126 retval = fmod (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1127 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1128 }
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 else if (y_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1131 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1132 if (is_float)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1133 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1134 float y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1135
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1136 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	1137 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1138 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	1139
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1140 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1141 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	1142 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1143 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1144 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1145 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1146 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1147
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1148 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	1149 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1150 if (arg_x.is_sparse_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1151 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1152 SparseMatrix x = arg_x.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1153
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1154 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1155 retval = map_s_d (fmod, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1156 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1157 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1158 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1159 NDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1160
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1161 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1162 retval = map_m_d (fmod, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1163 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1164 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1165 }
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 else if (x_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1168 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1169 if (arg_y.is_sparse_type ())
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1170 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1171 SparseMatrix y = arg_y.sparse_matrix_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1172
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1173 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	1174 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1175 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	1176
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1177 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	1178 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	1179 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1180 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1181 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1182 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1183 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1184
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1185 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1186 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1187 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1188
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1189 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1190 retval = map_f_fm (fmodf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1191 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1192 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1193 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1194 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1195 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	1196
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1197 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	1198 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1199 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	1200
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1201 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	1202 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	1203 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1204 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1205 }
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1206 else if (y_dims == x_dims)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1207 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1208 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	1209 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1210 SparseMatrix y = arg_y.sparse_matrix_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1211
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1212 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	1213 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1214 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	1215
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1216 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	1217 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	1218 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1219 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1220 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1221 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1222 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1223
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1224 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1225 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1226 FloatNDArray x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1227
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1228 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1229 retval = map_fm_fm (fmodf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1230 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1231 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1232 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1233 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1234 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	1235
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1236 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	1237 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1238 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	1239
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1240 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	1241 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	1242 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1243 }
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 else
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1246 error ("fmod: nonconformant matrices");
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1247 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1248 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1249 print_usage ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1250
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1251 return retval;
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1252 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1253
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1254 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1255 %!assert (size (fmod (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1256 %!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	1257 %!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	1258 %!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	1259 %!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	1260 */
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1261
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1262 // 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	1263
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1264 #define NATIVE_REDUCTION_1(FCN, TYPE, DIM) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1265 (arg.is_ ## TYPE ## _type ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1266 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1267 TYPE ## NDArray tmp = arg. TYPE ##_array_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1268 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1269 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1270 retval = tmp.FCN (DIM); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1271 }
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 #define NATIVE_REDUCTION(FCN) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1274 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1275 octave_value retval; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1276 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1277 int nargin = args.length (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1278 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1279 bool isnative = false; \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1280 bool isdouble = false; \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1281 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1282 if (nargin > 1 && args(nargin - 1).is_string ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1283 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1284 std::string str = args(nargin - 1).string_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1285 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1286 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1287 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1288 if (str == "native") \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1289 isnative = true; \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1290 else if (str == "double") \
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1291 isdouble = true; \
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1292 else \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1293 error ("sum: unrecognized string argument"); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1294 nargin --; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1295 } \
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 if (nargin == 1 \|\| nargin == 2) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1299 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1300 octave_value arg = args(0); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1301 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1302 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	1303 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1304 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1305 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1306 if (dim >= -1) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1307 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1308 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1309 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1310 if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1311 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1312 SparseMatrix tmp = arg.sparse_matrix_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1313 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1314 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1315 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1316 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1317 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1318 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1319 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	1320 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1321 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1322 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1323 } \
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 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1326 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1327 if (isnative) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1328 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1329 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	1330 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	1331 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	1332 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	1333 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	1334 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	1335 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	1336 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	1337 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	1338 else if (arg.is_char_matrix ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1339 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1340 error (#FCN, ": invalid char type"); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1341 } \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1342 else if (!isdouble && arg.is_single_type ()) \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1343 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1344 if (arg.is_complex_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1345 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1346 FloatComplexNDArray tmp = \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1347 arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1348 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1349 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1350 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1351 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1352 else if (arg.is_real_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1353 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1354 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1355 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1356 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1357 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1358 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1359 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1360 else if (arg.is_complex_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1361 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1362 ComplexNDArray tmp = arg.complex_array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1363 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1364 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1365 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1366 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1367 else if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1368 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1369 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1370 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1371 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1372 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1373 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1374 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1375 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1376 gripe_wrong_type_arg (#FCN, arg); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1377 return retval; \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1378 } \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1379 } \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1380 else if (!isdouble && arg.is_single_type ()) \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1381 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1382 if (arg.is_real_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1383 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1384 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1385 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1386 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1387 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1388 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1389 else if (arg.is_complex_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1390 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1391 FloatComplexNDArray tmp = \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1392 arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1393 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1394 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1395 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1396 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1397 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1398 else if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1399 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1400 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1401 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1402 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1403 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1404 } \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1405 else if (arg.is_complex_type ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1406 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1407 ComplexNDArray tmp = arg.complex_array_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1408 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1409 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1410 retval = tmp.FCN (dim); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1411 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1412 else \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1413 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1414 gripe_wrong_type_arg (#FCN, arg); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1415 return retval; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1416 } \
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 else \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1420 error (#FCN ": invalid dimension argument = %d", dim + 1); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1421 } \
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 else \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1425 print_usage (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1426 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1427 return retval
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1428
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1429 #define DATA_REDUCTION(FCN) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1430 \
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	1431 octave_value retval; \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1432 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1433 int nargin = args.length (); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1434 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1435 if (nargin == 1 \|\| nargin == 2) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1436 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1437 octave_value arg = args(0); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1438 \
3864 e78705239df5 [project @ 2001-11-16 12:56:20 by jwe] jwe parents: 3797 diff changeset	1439 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	1440 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1441 if (! error_state) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1442 { \
4556 773a21e4fce8 [project @ 2003-10-28 05:02:10 by jwe] jwe parents: 4554 diff changeset	1443 if (dim >= -1) \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1444 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1445 if (arg.is_real_type ()) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1446 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1447 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1448 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1449 SparseMatrix tmp = arg.sparse_matrix_value (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1450 \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1451 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1452 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1453 } \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1454 else if (arg.is_single_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1455 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1456 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1457 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1458 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1459 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1460 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1461 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1462 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1463 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1464 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1465 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1466 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1467 } \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1468 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1469 else if (arg.is_complex_type ()) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1470 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1471 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1472 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1473 SparseComplexMatrix tmp = arg.sparse_complex_matrix_value (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1474 \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1475 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1476 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1477 } \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1478 else if (arg.is_single_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1479 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1480 FloatComplexNDArray tmp = arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1481 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1482 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1483 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1484 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1485 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1486 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1487 ComplexNDArray tmp = arg.complex_array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1488 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1489 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1490 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1491 } \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1492 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1493 else \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1494 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1495 gripe_wrong_type_arg (#FCN, arg); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1496 return retval; \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1497 } \
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 else \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1500 error (#FCN ": invalid dimension argument = %d", dim + 1); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1501 } \
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 else \
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1504 print_usage (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1505 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1506 return retval
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1507
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1508 DEFUN (cumprod, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1509 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1510 @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	1511 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	1512 @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	1513 products).\n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1514 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1515 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	1516 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	1517 same orientation as @var{x}.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1518 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1519 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1520 DATA_REDUCTION (cumprod);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1521 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1522
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1523 /*
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 %!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	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 ([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	1528 %!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	1529
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1530 %!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	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([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	1533 %!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	1534
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1535 %!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	1536
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1537 %!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	1538 %!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	1539
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1540 %!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	1541 %!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	1542
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
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1545 DEFUN (cumsum, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1546 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1547 @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	1548 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	1549 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	1550 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1551 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	1552 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	1553 same orientation as @var{x}.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1554 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1555 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1556 DATA_REDUCTION (cumsum);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1557 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1558
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1559 /*
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 %!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	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 ([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	1564 %!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	1565
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1566 %!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	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([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	1569 %!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	1570
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1571 %!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	1572
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1573 %!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	1574 %!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	1575
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1576 %!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	1577 %!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	1578
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
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1581 DEFUN (diag, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1582 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1583 @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	1584 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	1585 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	1586 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	1587 @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	1588 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	1589 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1590 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1591 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1592 diag ([1, 2, 3], 1)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1593 @result{} 0 1 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1594 0 0 2 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1595 0 0 0 3\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1596 0 0 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1597 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1598 @end example\n\
6772 315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1599 \n\
315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1600 @noindent\n\
315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1601 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	1602 @var{k}-th diagonal of the matrix.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1603 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1604 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	1605 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1606
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1607 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1608
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	1609 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	1610 retval = args(0).diag();
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	1611 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	1612 {
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1613 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	1614
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1615 if (error_state)
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1616 error ("diag: invalid second argument");
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1617 else
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1618 retval = args(0).diag(k);
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1619 }
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1620 else if (nargin == 3)
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1621 {
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1622 octave_value arg0 = args(0);
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1623 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	1624 {
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1625 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	1626 if (! error_state)
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1627 retval = arg0.diag ().resize (dim_vector (m, n));
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1628 else
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1629 error ("diag: invalid dimensions");
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1630 }
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1631 else
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1632 error ("diag: first argument must be a vector");
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1633 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1634 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1635 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1636
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1637 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1638 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1639
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1640 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1641
8459 d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1642 %!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	1643 %!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	1644 %!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	1645 %!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	1646 %!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	1647
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1648 %!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	1649 %!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	1650 %!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	1651
8459 d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1652 %!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	1653 %!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	1654 %!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	1655 %!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	1656 %!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	1657
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1658 %!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	1659 %!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	1660 %!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	1661
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1662 %!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	1663 %!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	1664 %!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	1665 %!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	1666 %!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	1667
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1668 %!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	1669 %!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	1670 %!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	1671
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1672 %!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	1673
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
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1676 DEFUN (prod, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1677 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1678 @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	1679 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	1680 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	1681 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1682 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	1683 return the product of the elements.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1684 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1685 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1686 DATA_REDUCTION (prod);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1687 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1688
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1689 /*
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 %!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	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 ([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	1694 %!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	1695
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1696 %!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	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([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	1699 %!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	1700
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1701 %!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	1702
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1703 %!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	1704 %!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	1705 %!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	1706 %!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	1707 %!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	1708 %!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	1709 %!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	1710 %!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	1711 %!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	1712 %!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	1713 %!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	1714 %!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	1715 %!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	1716 %!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	1717
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1718 %!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	1719 %!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	1720 %!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	1721 %!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	1722 %!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	1723 %!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	1724 %!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	1725 %!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	1726 %!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	1727 %!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	1728 %!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	1729 %!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	1730 %!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	1731 %!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	1732
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
8107 8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1735 #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	1736 do \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1737 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1738 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	1739 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	1740 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1741 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	1742 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1743 OCTAVE_QUIT; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1744 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1745 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	1746 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1747 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	1748 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1749 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	1750 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1751 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	1752 return retval; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1753 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1754 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	1755 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1756 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	1757 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1758 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	1759 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	1760 break; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1761 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1762 else \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1763 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	1764 } \
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 while (0)
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1768
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1769 #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	1770 do \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1771 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1772 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	1773 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1774 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	1775 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1776 retval = result; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1777 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1778 while (0)
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1779
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1780 static octave_value
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1781 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	1782 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1783 octave_value retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1784
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1785 int n_args = args.length ();
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1786
5714 24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1787 if (n_args == 1)
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1788 retval = Matrix ();
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1789 else if (n_args == 2)
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1790 retval = args(1);
5507 273612001e3a [project @ 2005-10-26 08:01:24 by dbateman] dbateman parents: 5476 diff changeset	1791 else if (n_args > 2)
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1792 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1793 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	1794
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1795 if (error_state)
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1796 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1797 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	1798 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1799 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1800
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1801 if (dim >= 0)
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1802 {
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1803
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1804 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	1805 std::string result_type = args(1).class_name ();
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1806
8107 8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1807 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	1808 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	1809 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	1810 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	1811
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1812 for (int i = 2; i < args.length (); i++)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1813 {
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1814 // 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	1815 // dimensions of the final array after concatenation.
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1816
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1817 if (! dv.concat (args(i).dims (), dim))
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1818 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1819 // Dimensions do not match.
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1820 error ("cat: dimension mismatch");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1821 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1822 }
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1823
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1824 result_type =
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1825 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	1826
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1827 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	1828 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	1829 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	1830 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	1831 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	1832 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	1833 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	1834 any_sparse_p = true;
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1835 }
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1836
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1837 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	1838 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1839 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	1840 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1841 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	1842 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	1843 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1844 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	1845 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1846 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1847 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1848 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	1849 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	1850 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1851 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	1852 }
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 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	1855 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1856 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	1857 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	1858 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1859 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	1860 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	1861 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1862 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	1863 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1864 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	1865
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1866 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	1867
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1868 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	1869
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1870 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	1871
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1872 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	1873 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1874 else if (result_type == "logical")
5533 667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1875 {
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1876 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	1877 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	1878 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1879 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	1880 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1881 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	1882 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	1883 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	1884 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	1885 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	1886 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	1887 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	1888 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	1889 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	1890 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	1891 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	1892 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	1893 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	1894 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	1895 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	1896 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	1897 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1898 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1899 // 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	1900 // 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	1901 // 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	1902 // 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	1903 // 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	1904 // 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	1905 // 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	1906 //
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1907 // 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	1908 // 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	1909 // (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	1910 // 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	1911 // 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	1912
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1913 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	1914 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	1915
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1916 if (error_state)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1917 return retval;
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1918
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1919 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	1920 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	1921
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1922 for (int j = 1; j < n_args; j++)
6401 f8cbc0871ed6 [project @ 2007-03-09 15:34:45 by dbateman] dbateman parents: 6399 diff changeset	1923 {
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1924 // 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	1925 // 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	1926 // 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	1927 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	1928
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1929 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	1930 return retval;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1931
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1932 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	1933
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1934 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	1935 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1936 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	1937 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	1938 break;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1939 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1940 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1941 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	1942 dv_tmp (dim) : 1);
6401 f8cbc0871ed6 [project @ 2007-03-09 15:34:45 by dbateman] dbateman parents: 6399 diff changeset	1943 }
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1944 retval = tmp;
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1945 }
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1946
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1947 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	1948 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1949 // 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	1950 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	1951 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	1952 }
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1953 }
5533 667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1954 else
667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1955 error ("%s: invalid dimension argument", fname.c_str ());
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1956 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1957 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1958 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	1959
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1960 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1961 }
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 DEFUN (horzcat, args, ,
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1964 "-- texinfo --\n\
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1965 @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	1966 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	1967 @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	1968 @seealso{cat, vertcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	1969 @end deftypefn")
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1970 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1971 octave_value_list args_tmp = args;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1972
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1973 int dim = 2;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1974
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1975 octave_value d (dim);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1976
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1977 args_tmp.prepend (d);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1978
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1979 return do_cat (args_tmp, "horzcat");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1980 }
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 DEFUN (vertcat, args, ,
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1983 "-- texinfo --\n\
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1984 @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	1985 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	1986 @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	1987 @seealso{cat, horzcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	1988 @end deftypefn")
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1989 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1990 octave_value_list args_tmp = args;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1991
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1992 int dim = 1;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1993
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1994 octave_value d (dim);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1995
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1996 args_tmp.prepend (d);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1997
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1998 return do_cat (args_tmp, "vertcat");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1999 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2000
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2001 DEFUN (cat, args, ,
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2002 "-- texinfo --\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2003 @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	2004 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	2005 @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	2006 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2007 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2008 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2009 A = ones (2, 2);\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2010 B = zeros (2, 2);\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2011 cat (2, A, B)\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2012 @result{} ans =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2013 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2014 1 1 0 0\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 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2017 @end example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2018 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2019 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	2020 second dimension the following way:\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2021 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2022 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2023 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2024 [A, B].\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2025 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2026 @end example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2027 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2028 @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	2029 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	2030 following example shows:\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2031 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2032 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2033 cat (4, ones(2, 2), zeros (2, 2))\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2034 @result{} ans =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2035 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2036 ans(:,:,1,1) =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2037 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2038 1 1\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 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2041 ans(:,:,1,2) =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2042 0 0\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 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2045 @end example\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2046 @seealso{horzcat, vertcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2047 @end deftypefn")
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2048 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	2049 return do_cat (args, "cat");
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2050 }
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2051
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2052 /*
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 %!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	2055 %! 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	2056 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2057 %! 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	2058 %! 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	2059 %! 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	2060 %! 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	2061 %! 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	2062 %! 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	2063 %! 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	2064 %! 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	2065 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2066 %! 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	2067 %! 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	2068 %! 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	2069 %! 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	2070 %! 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	2071 %! 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	2072 %! 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	2073 %! 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	2074 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2075 %! 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	2076 %! 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	2077 %! 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	2078 %! 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	2079 %! 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	2080 %! 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	2081 %! 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	2082 %! 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	2083 %! 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	2084 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2085 %! 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	2086 %! 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	2087 %! 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	2088 %! 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	2089 %! 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	2090 %! 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	2091 %! 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	2092 %! 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	2093 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2094 %! 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	2095 %! 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	2096 %! 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	2097 %! 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	2098 %! 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	2099 %! 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	2100 %! 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	2101 %! 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	2102 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2103 %! 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	2104 %! 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	2105 %! 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	2106 %! 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	2107 %! 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	2108 %! 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	2109 %! 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	2110 %! 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	2111 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2112 %! 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	2113 %! 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	2114 %! 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	2115 %! 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	2116 %! 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	2117 %! 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	2118 %! 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	2119 %! 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	2120 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2121 %! 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	2122 %! 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	2123 %! 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	2124 %! 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	2125 %! 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	2126 %! 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	2127 %! 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	2128 %! 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	2129 %! endif
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2130 %! ret = true;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2131
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2132 %!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	2133 %!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	2134 %!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	2135 %!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	2136
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2137 %!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	2138 %!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	2139 %!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	2140 %!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	2141 %!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	2142 %!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	2143 %!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	2144 %!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	2145 %!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	2146 %!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	2147 %!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	2148 %!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	2149 %!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	2150 %!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	2151 %!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	2152 %!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	2153 %!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	2154 %!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	2155 %!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	2156 %!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	2157
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2158 %!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	2159 %!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	2160 %!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	2161 %!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	2162 %!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	2163 %!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	2164 %!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	2165 %!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	2166 %!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	2167 %!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	2168 %!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	2169 %!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	2170 %!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	2171 %!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	2172 %!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	2173 %!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	2174 %!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	2175 %!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	2176 %!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	2177 %!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	2178
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
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2181 static octave_value
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2182 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	2183 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2184 octave_value retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2185
5148 9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2186 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	2187 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2188 Array<int> vec = args(1).int_vector_value ();
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2189
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	2190 // 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	2191 // here and pass that to permute?
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2192
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2193 int n = vec.length ();
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2194
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2195 for (int i = 0; i < n; i++)
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2196 vec(i)--;
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2197
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2198 octave_value ret = args(0).permute (vec, inv);
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2199
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2200 if (! error_state)
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2201 retval = ret;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2202 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2203 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2204 print_usage ();
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2205
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2206 return retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2207 }
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 DEFUN (permute, args, ,
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2210 "-- texinfo --\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2211 @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	2212 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	2213 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	2214 @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	2215 @seealso{ipermute}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2216 @end deftypefn")
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2217 {
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2218 return do_permute (args, false);
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2219 }
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 DEFUN (ipermute, args, ,
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2222 "-- texinfo --\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2223 @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	2224 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	2225 \n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2226 @example\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2227 ipermute (permute (a, perm), perm)\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2228 @end example\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2229 returns the original array @var{a}.\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2230 @seealso{permute}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2231 @end deftypefn")
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2232 {
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2233 return do_permute (args, true);
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2234 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2235
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2236 DEFUN (length, args, ,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2237 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2238 @deftypefn {Built-in Function} {} length (@var{a})\n\
4176 b8ec44432831 [project @ 2002-11-13 02:49:14 by jwe] jwe parents: 4153 diff changeset	2239 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	2240 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	2241 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	2242 @end deftypefn")
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2243 {
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2244 octave_value retval;
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2245
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2246 if (args.length () == 1)
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2247 {
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2248 int len = args(0).length ();
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2249
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2250 if (! error_state)
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	2251 retval = len;
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2252 }
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2253 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2254 print_usage ();
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2255
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2256 return retval;
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2257 }
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2258
4554 78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2259 DEFUN (ndims, args, ,
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2260 "-- texinfo --\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2261 @deftypefn {Built-in Function} {} ndims (@var{a})\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2262 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	2263 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	2264 Trailing singleton dimensions are not counted.\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2265 @end deftypefn")
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2266 {
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2267 octave_value retval;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2268
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2269 if (args.length () == 1)
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2270 {
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2271 int n_dims = args(0).ndims ();
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2272
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2273 if (! error_state)
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2274 retval = n_dims;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2275 }
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2276 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2277 print_usage ();
4554 78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2278
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2279 return retval;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2280 }
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2281
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2282 DEFUN (numel, args, ,
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2283 "-- texinfo --\n\
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2284 @deftypefn {Built-in Function} {} numel (@var{a})\n\
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2285 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	2286 @seealso{size}\n\
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2287 @end deftypefn")
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2288 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2289 octave_value retval;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2290
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2291 if (args.length () == 1)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2292 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2293 int numel = args(0).numel ();
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2294
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2295 if (! error_state)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2296 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2297 if (numel < 0)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2298 numel = 0;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2299
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2300 retval = numel;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2301 }
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 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2304 print_usage ();
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2305
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2306 return retval;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2307 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2308
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2309 DEFUN (size, args, nargout,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2310 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2311 @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	2312 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	2313 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2314 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	2315 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	2316 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	2317 etc. For example,\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2318 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2319 @example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2320 @group\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2321 size ([1, 2; 3, 4; 5, 6])\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2322 @result{} [ 3, 2 ]\n\
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2323 \n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2324 [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	2325 @result{} nr = 3\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2326 @result{} nc = 2\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2327 @end group\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2328 @end example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2329 \n\
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2330 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	2331 corresponding dimension. For example\n\
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2332 \n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2333 @example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2334 size ([1, 2; 3, 4; 5, 6], 2)\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2335 @result{} 2\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2336 @end example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2337 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2338 @noindent\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2339 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	2340 @seealso{numel}\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2341 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2342 {
2086 bfb775fb6fe8 [project @ 1996-04-25 05:55:19 by jwe] jwe parents: 1996 diff changeset	2343 octave_value_list retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2344
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2345 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2346
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2347 if (nargin == 1)
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2348 {
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2349 dim_vector dimensions = args(0).dims ();
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2350
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2351 int ndims = dimensions.length ();
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2352
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2353 Matrix m (1, ndims);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2354
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2355 if (nargout > 1)
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2356 {
5991 265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2357 for (int i = nargout-1; i >= ndims; i--)
265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2358 retval(i) = 1;
265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2359
6197 c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2360 if (ndims > nargout)
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2361 {
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2362 octave_idx_type d = 1;
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2363
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2364 while (ndims >= nargout)
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2365 d *= dimensions(--ndims);
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2366
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2367 retval(ndims) = d;
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2368 }
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2369
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2370 while (ndims--)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2371 retval(ndims) = dimensions(ndims);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2372 }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2373 else
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2374 {
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2375 for (int i = 0; i < ndims; i++)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2376 m(0, i) = dimensions(i);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2377
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2378 retval(0) = m;
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2379 }
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2380 }
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2381 else if (nargin == 2 && nargout < 2)
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2382 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	2383 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	2384
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2385 if (error_state)
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2386 error ("size: expecting scalar as second argument");
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2387 else
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2388 {
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2389 dim_vector dv = args(0).dims ();
e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2390
4911 14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2391 if (nd > 0)
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2392 {
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2393 if (nd <= dv.length ())
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2394 retval(0) = dv(nd-1);
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2395 else
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2396 retval(0) = 1;
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2397 }
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2398 else
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2399 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	2400 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2401 }
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2402 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2403 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2404
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2405 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2406 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2407
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2408 DEFUN (size_equal, args, ,
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2409 "-- texinfo --\n\
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2410 @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	2411 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	2412 Trailing singleton dimensions are ignored.\n\
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2413 @seealso{size, numel}\n\
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2414 @end deftypefn")
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2415 {
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2416 octave_value retval;
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2417
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2418 int nargin = args.length ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2419
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2420 if (nargin >= 2)
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2421 {
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2422 retval = true;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2423
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2424 dim_vector a_dims = args(0).dims ();
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2425 a_dims.chop_trailing_singletons ();
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2426
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2427 for (int i = 1; i < nargin; ++i)
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2428 {
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2429 dim_vector b_dims = args(i).dims ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2430 b_dims.chop_trailing_singletons ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2431
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2432 if (a_dims != b_dims)
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2433 {
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2434 retval = false;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2435 break;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2436 }
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2437 }
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2438 }
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2439 else
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2440 print_usage ();
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2441
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2442 return retval;
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2443 }
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2444
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2445 DEFUN (nnz, args, ,
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2446 "-- texinfo --\n\
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2447 @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	2448 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	2449 @seealso{sparse}\n\
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2450 @end deftypefn")
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2451 {
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2452 octave_value retval;
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2453
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2454 if (args.length () == 1)
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2455 retval = args(0).nnz ();
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2456 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2457 print_usage ();
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2458
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2459 return retval;
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2460 }
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2461
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2462 DEFUN (nzmax, args, ,
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2463 "-- texinfo --\n\
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2464 @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	2465 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	2466 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	2467 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	2468 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	2469 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	2470 @seealso{sparse, spalloc}\n\
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2471 @end deftypefn")
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2472 {
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2473 octave_value retval;
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2474
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2475 if (args.length() == 1)
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2476 retval = args(0).nzmax ();
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2477 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2478 print_usage ();
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2479
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2480 return retval;
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2481 }
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2482
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2483 DEFUN (rows, args, ,
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2484 "-- texinfo --\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2485 @deftypefn {Built-in Function} {} rows (@var{a})\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2486 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	2487 @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	2488 @end deftypefn")
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2489 {
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2490 octave_value retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2491
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2492 if (args.length () == 1)
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2493 retval = args(0).rows ();
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2494 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2495 print_usage ();
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2496
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2497 return retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2498 }
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 DEFUN (columns, args, ,
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2501 "-- texinfo --\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2502 @deftypefn {Built-in Function} {} columns (@var{a})\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2503 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	2504 @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	2505 @end deftypefn")
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2506 {
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2507 octave_value retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2508
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2509 if (args.length () == 1)
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2510 retval = args(0).columns ();
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2511 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2512 print_usage ();
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2513
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2514 return retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2515 }
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2516
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2517 DEFUN (sum, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2518 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2519 @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	2520 @deftypefnx {Built-in Function} {} sum (@dots{}, 'native')\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2521 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	2522 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	2523 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2524 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	2525 return the sum of the elements.\n\
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2526 \n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2527 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	2528 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	2529 double type. For example\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2530 \n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2531 @example\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2532 sum ([true, true])\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2533 @result{} 2\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2534 sum ([true, true], 'native')\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2535 @result{} true\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2536 @end example\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2537 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2538 {
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2539 NATIVE_REDUCTION (sum);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2540 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2541
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2542 /*
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 %!assert (sum([true,true]), 2)
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2545 %!assert (sum([true,true],'native'), true)
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2546 %!assert (sum(int8([127,10,-20])), 117);
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2547 %!assert (sum(int8([127,10,-20]),'native'), int8(107));
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2548
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2549 %!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	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 ([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	2552 %!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	2553
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2554 %!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	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([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	2557 %!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	2558
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2559 %!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	2560
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2561 %!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	2562 %!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	2563 %!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	2564 %!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	2565 %!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	2566 %!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	2567 %!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	2568 %!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	2569 %!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	2570 %!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	2571 %!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	2572 %!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	2573 %!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	2574 %!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	2575 %!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	2576 %!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	2577 %!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	2578 %!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	2579 %!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	2580
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2581 %!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	2582 %!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	2583 %!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	2584 %!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	2585 %!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	2586 %!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	2587 %!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	2588 %!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	2589 %!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	2590 %!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	2591 %!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	2592 %!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	2593 %!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	2594 %!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	2595 %!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	2596 %!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	2597 %!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	2598 %!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	2599 %!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	2600
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2601 */
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2602
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2603 DEFUN (sumsq, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2604 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2605 @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	2606 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	2607 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	2608 \n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2609 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	2610 return the sum of squares of the elements.\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2611 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2612 This function is conceptually equivalent to computing\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2613 @example\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2614 sum (x .* conj (x), dim)\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2615 @end example\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2616 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	2617 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2618 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2619 DATA_REDUCTION (sumsq);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2620 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2621
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2622 /*
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 %!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	2625 %!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	2626 %!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	2627
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2628 %!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	2629 %!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	2630 %!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	2631
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2632 %!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	2633
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2634 %!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	2635 %!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	2636
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2637 %!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	2638 %!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	2639
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
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2642 DEFUN (islogical, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2643 "-- texinfo --\n\
7144 30c0533e39ae [project @ 2007-11-09 17:37:24 by jwe] jwe parents: 7112 diff changeset	2644 @deftypefn {Built-in Function} {} islogical (@var{x})\n\
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2645 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	2646 @end deftypefn")
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2647 {
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2648 octave_value retval;
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2649
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2650 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2651 retval = args(0).is_bool_type ();
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2652 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2653 print_usage ();
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2654
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2655 return retval;
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2656 }
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2657
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2658 DEFALIAS (isbool, islogical);
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2659
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2660 /*
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 %!assert (islogical(true), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2663 %!assert (islogical(false), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2664 %!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	2665 %!assert (islogical(1), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2666 %!assert (islogical(1i), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2667 %!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	2668 %!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	2669 %!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	2670 %!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	2671
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
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2674 DEFUN (isinteger, args, ,
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2675 "-- texinfo --\n\
6230 06bee64edc08 [project @ 2007-01-08 16:59:35 by jwe] jwe parents: 6223 diff changeset	2676 @deftypefn {Built-in Function} {} isinteger (@var{x})\n\
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2677 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	2678 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	2679 Octave are double precision floating point values.\n\
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2680 @seealso{isreal, isnumeric, class, isa}\n\
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2681 @end deftypefn")
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2682 {
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2683 octave_value retval;
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2684
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2685 if (args.length () == 1)
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2686 retval = args(0).is_integer_type ();
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2687 else
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2688 print_usage ();
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2689
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2690 return retval;
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2691 }
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2692
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	2693 DEFUN (iscomplex, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2694 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	2695 @deftypefn {Built-in Function} {} iscomplex (@var{x})\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2696 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	2697 @end deftypefn")
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2698 {
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2699 octave_value retval;
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2700
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2701 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2702 retval = args(0).is_complex_type ();
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2703 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2704 print_usage ();
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2705
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2706 return retval;
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2707 }
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2708
7576 7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2709 DEFUN (isfloat, args, ,
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2710 "-- texinfo --\n\
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2711 @deftypefn {Built-in Function} {} isfloat (@var{x})\n\
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2712 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	2713 @end deftypefn")
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2714 {
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2715 octave_value retval;
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2716
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2717 if (args.length () == 1)
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2718 retval = args(0).is_float_type ();
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2719 else
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2720 print_usage ();
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2721
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2722 return retval;
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2723 }
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2724
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	2725 // FIXME -- perhaps this should be implemented with an
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2726 // octave_value member function?
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2727
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2728 DEFUN (complex, args, ,
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2729 "-- texinfo --\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2730 @deftypefn {Built-in Function} {} complex (@var{val})\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2731 @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	2732 Convert @var{x} to a complex value.\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2733 @end deftypefn")
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2734 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2735 octave_value retval;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2736
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2737 int nargin = args.length ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2738
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2739 if (nargin == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2740 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2741 octave_value arg = args(0);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2742
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2743 if (arg.is_complex_type ())
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2744 retval = arg;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2745 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2746 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2747 if (arg.is_sparse_type ())
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2748 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2749 SparseComplexMatrix val = arg.sparse_complex_matrix_value ();
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2750
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2751 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2752 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	2753 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2754 else if (arg.is_single_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2755 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2756 if (arg.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2757 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2758 FloatComplex val = arg.float_complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2759
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2760 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2761 retval = octave_value (new octave_float_complex (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2762 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2763 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2764 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2765 FloatComplexNDArray val = arg.float_complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2766
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2767 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2768 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	2769 }
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2770 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2771 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2772 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2773 if (arg.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2774 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2775 Complex val = arg.complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2776
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2777 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2778 retval = octave_value (new octave_complex (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2779 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2780 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2781 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2782 ComplexNDArray val = arg.complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2783
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2784 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2785 retval = octave_value (new octave_complex_matrix (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2786 }
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2787 }
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 if (error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2790 error ("complex: invalid conversion");
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2791 }
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 else if (nargin == 2)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2794 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2795 octave_value re = args(0);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2796 octave_value im = args(1);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2797
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2798 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	2799 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2800 const SparseMatrix re_val = re.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2801 const SparseMatrix im_val = im.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2802
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2803 if (!error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2804 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2805 if (re.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2806 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2807 SparseComplexMatrix result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2808 if (re_val.nnz () == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2809 result = Complex(0, 1) * SparseComplexMatrix (im_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2810 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2811 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2812 result = SparseComplexMatrix (im_val.dims (), re_val (0));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2813 octave_idx_type nr = im_val.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2814 octave_idx_type nc = im_val.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2815
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2816 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	2817 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2818 octave_idx_type off = j * nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2819 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	2820 i < im_val.cidx(j + 1); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2821 result.data (im_val.ridx(i) + off) =
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 Complex (0, im_val.data (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2824 }
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 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	2827 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2828 else if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2829 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2830 SparseComplexMatrix result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2831 if (im_val.nnz () == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2832 result = SparseComplexMatrix (re_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2833 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2834 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2835 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	2836 octave_idx_type nr = re_val.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2837 octave_idx_type nc = re_val.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2838
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2839 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	2840 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2841 octave_idx_type off = j * nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2842 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	2843 i < re_val.cidx(j + 1); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2844 result.data (re_val.ridx(i) + off) =
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 re_val.data (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2847 }
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 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	2850 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2851 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2852 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2853 if (re_val.dims () == im_val.dims ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2854 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2855 SparseComplexMatrix result = SparseComplexMatrix(re_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2856 + Complex(0, 1) * SparseComplexMatrix (im_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2857 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	2858 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2859 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2860 error ("complex: dimension mismatch");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2861 }
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 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	2865 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2866 if (re.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2867 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2868 float re_val = re.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2869
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2870 if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2871 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2872 float im_val = im.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2873
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2874 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2875 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	2876 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2877 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2878 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2879 const FloatNDArray im_val = im.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2880
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2881 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2882 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2883 FloatComplexNDArray result (im_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2884
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2885 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	2886 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	2887
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2888 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	2889 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2893 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2894 const FloatNDArray re_val = re.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2895
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2896 if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2897 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2898 float im_val = im.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2899
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2900 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2901 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2902 FloatComplexNDArray result (re_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2903
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2904 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	2905 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	2906
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2907 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	2908 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2911 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2912 const FloatNDArray im_val = im.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2913
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2914 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2915 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2916 if (re_val.dims () == im_val.dims ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2917 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2918 FloatComplexNDArray result (re_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2919
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2920 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	2921 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	2922
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2923 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	2924 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2925 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2926 error ("complex: dimension mismatch");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2927 }
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 else if (re.numel () == 1)
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2932 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2933 double re_val = re.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2934
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2935 if (im.numel () == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2936 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2937 double im_val = im.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2938
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2939 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2940 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	2941 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2942 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2943 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2944 const NDArray im_val = im.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2945
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2946 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2947 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2948 ComplexNDArray result (im_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2949
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2950 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	2951 result.xelem (i) = Complex (re_val, im_val(i));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2952
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2953 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2954 }
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 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2958 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2959 const NDArray re_val = re.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2960
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2961 if (im.numel () == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2962 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2963 double im_val = im.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2964
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2965 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2966 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2967 ComplexNDArray result (re_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2968
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2969 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	2970 result.xelem (i) = Complex (re_val(i), im_val);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2971
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2972 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2973 }
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 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2976 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2977 const NDArray im_val = im.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2978
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2979 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2980 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2981 if (re_val.dims () == im_val.dims ())
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2982 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2983 ComplexNDArray result (re_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2984
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2985 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	2986 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	2987
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2988 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2989 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2990 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2991 error ("complex: dimension mismatch");
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2992 }
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 if (error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2997 error ("complex: invalid conversion");
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2998 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2999 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3000 print_usage ();
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3001
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3002 return retval;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3003 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3004
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3005 DEFUN (isreal, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3006 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3007 @deftypefn {Built-in Function} {} isreal (@var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3008 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	3009 @end deftypefn")
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3010 {
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3011 octave_value retval;
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3012
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3013 if (args.length () == 1)
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3014 retval = args(0).is_real_type ();
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3015 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3016 print_usage ();
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3017
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3018 return retval;
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3019 }
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3020
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3021 DEFUN (isempty, args, ,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3022 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3023 @deftypefn {Built-in Function} {} isempty (@var{a})\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3024 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	3025 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	3026 @end deftypefn")
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3027 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3028 octave_value retval = false;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3029
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3030 if (args.length () == 1)
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	3031 retval = args(0).is_empty ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3032 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3033 print_usage ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3034
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3035 return retval;
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3036 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3037
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3038 DEFUN (isnumeric, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3039 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3040 @deftypefn {Built-in Function} {} isnumeric (@var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3041 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	3042 @end deftypefn")
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3043 {
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3044 octave_value retval;
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3045
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3046 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3047 retval = args(0).is_numeric_type ();
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3048 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3049 print_usage ();
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3050
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3051 return retval;
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3052 }
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3053
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3054 DEFUN (islist, args, ,
3526 cc21933776a1 [project @ 2000-02-02 10:53:27 by jwe] jwe parents: 3523 diff changeset	3055 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3056 @deftypefn {Built-in Function} {} islist (@var{x})\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3057 Return nonzero if @var{x} is a list.\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3058 @end deftypefn")
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3059 {
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3060 octave_value retval;
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3061
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3062 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3063 retval = args(0).is_list ();
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3064 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3065 print_usage ();
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3066
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3067 return retval;
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3068 }
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3069
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3070 DEFUN (ismatrix, args, ,
3321 6923abb04e16 [project @ 1999-10-26 18:15:30 by jwe] jwe parents: 3307 diff changeset	3071 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3072 @deftypefn {Built-in Function} {} ismatrix (@var{a})\n\
3321 6923abb04e16 [project @ 1999-10-26 18:15:30 by jwe] jwe parents: 3307 diff changeset	3073 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	3074 @end deftypefn")
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3075 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3076 octave_value retval = false;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3077
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3078 if (args.length () == 1)
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3079 {
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3080 octave_value arg = args(0);
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3081
3212 bf61c443a366 [project @ 1998-11-05 04:24:45 by jwe] jwe parents: 3209 diff changeset	3082 if (arg.is_scalar_type () \|\| arg.is_range ())
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3083 retval = true;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3084 else if (arg.is_matrix_type ())
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3085 retval = (arg.rows () >= 1 && arg.columns () >= 1);
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3086 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3087 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3088 print_usage ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3089
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3090 return retval;
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3091 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3092
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3093 /*
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 %!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	3096 %!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	3097 %!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	3098
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3099 %% 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	3100 %!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	3101
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3102 %!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	3103 %!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	3104 %!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	3105
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3106 %% 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	3107 %!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	3108
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3109 %!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	3110 %!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	3111 %!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	3112
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3113 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3114 %! 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	3115 %! 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	3116
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3117 %!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	3118 %!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	3119
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
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3122 static octave_value
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3123 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	3124 {
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3125 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3126
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3127 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3128
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3129 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	3130
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3131 dim_vector dims (1, 1);
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3132
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3133 if (nargin > 0 && args(nargin-1).is_string ())
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3134 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3135 std::string nm = args(nargin-1).string_value ();
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3136 nargin--;
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3137
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3138 dt = oct_data_conv::string_to_data_type (nm);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3139
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3140 if (error_state)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3141 return retval;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3142 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3143
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3144 switch (nargin)
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3145 {
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	3146 case 0:
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	3147 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3148
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	3149 case 1:
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3150 get_dimensions (args(0), fcn, dims);
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	3151 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3152
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3153 default:
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3154 {
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3155 dims.resize (nargin);
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3156
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3157 for (int i = 0; i < nargin; i++)
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3158 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3159 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	3160
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3161 if (error_state)
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3162 {
4732 b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	3163 error ("%s: expecting scalar integer arguments", fcn);
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3164 break;
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3165 }
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 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3169 }
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 if (! error_state)
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3172 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3173 dims.chop_trailing_singletons ();
4565 1db951a4fcd5 [project @ 2003-10-29 13:49:30 by jwe] jwe parents: 4563 diff changeset	3174
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3175 check_dimensions (dims, fcn);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3176
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	3177 // FIXME -- perhaps this should be made extensible by
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3178 // 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	3179 // the new value.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3180
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3181 // Note that automatic narrowing will handle conversion from
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3182 // NDArray to scalar.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3183
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3184 if (! error_state)
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3185 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3186 switch (dt)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3187 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3188 case oct_data_conv::dt_int8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3189 retval = int8NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3190 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3191
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3192 case oct_data_conv::dt_uint8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3193 retval = uint8NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3194 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3195
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3196 case oct_data_conv::dt_int16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3197 retval = int16NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3198 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3199
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3200 case oct_data_conv::dt_uint16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3201 retval = uint16NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3202 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3203
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3204 case oct_data_conv::dt_int32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3205 retval = int32NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3206 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3207
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3208 case oct_data_conv::dt_uint32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3209 retval = uint32NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3210 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3211
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3212 case oct_data_conv::dt_int64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3213 retval = int64NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3214 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3215
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3216 case oct_data_conv::dt_uint64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3217 retval = uint64NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3218 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3219
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3220 case oct_data_conv::dt_single:
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3221 retval = FloatNDArray (dims, val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3222 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3223
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3224 case oct_data_conv::dt_double:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3225 retval = NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3226 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3227
4986 fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3228 case oct_data_conv::dt_logical:
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3229 retval = boolNDArray (dims, val);
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3230 break;
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3231
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3232 default:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3233 error ("%s: invalid class name", fcn);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3234 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3235 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3236 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3237 }
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 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3240 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3241
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3242 static octave_value
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3243 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	3244 const char *fcn)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3245 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3246 octave_value retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3247
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3248 int nargin = args.length ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3249
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3250 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	3251
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3252 dim_vector dims (1, 1);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3253
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3254 if (nargin > 0 && args(nargin-1).is_string ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3255 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3256 std::string nm = args(nargin-1).string_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3257 nargin--;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3258
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3259 dt = oct_data_conv::string_to_data_type (nm);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3260
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3261 if (error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3262 return retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3263 }
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 switch (nargin)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3266 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3267 case 0:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3268 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3269
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3270 case 1:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3271 get_dimensions (args(0), fcn, dims);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3272 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3273
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3274 default:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3275 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3276 dims.resize (nargin);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3277
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3278 for (int i = 0; i < nargin; i++)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3279 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3280 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	3281
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3282 if (error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3283 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3284 error ("%s: expecting scalar integer arguments", fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3285 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3286 }
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 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3290 }
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 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3293 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3294 dims.chop_trailing_singletons ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3295
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3296 check_dimensions (dims, fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3297
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3298 // Note that automatic narrowing will handle conversion from
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3299 // NDArray to scalar.
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3300
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3301 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3302 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3303 switch (dt)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3304 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3305 case oct_data_conv::dt_single:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3306 retval = FloatNDArray (dims, fval);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3307 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3308
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3309 case oct_data_conv::dt_double:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3310 retval = NDArray (dims, val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3311 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3312
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3313 default:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3314 error ("%s: invalid class name", fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3315 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3316 }
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 return retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3321 }
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 static octave_value
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3324 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	3325 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3326 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3327
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3328 int nargin = args.length ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3329
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3330 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	3331
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3332 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3333
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3334 if (nargin > 0 && args(nargin-1).is_string ())
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3335 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3336 std::string nm = args(nargin-1).string_value ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3337 nargin--;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3338
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3339 dt = oct_data_conv::string_to_data_type (nm);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3340
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3341 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3342 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3343 }
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 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3346 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3347 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3348 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3349
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3350 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3351 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3352 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3353
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3354 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3355 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3356 dims.resize (nargin);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3357
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3358 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3359 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3360 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	3361
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3362 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3363 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3364 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3365 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3366 }
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 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3370 }
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 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3373 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3374 dims.chop_trailing_singletons ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3375
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3376 check_dimensions (dims, fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3377
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3378 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3379 // NDArray to scalar.
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3380
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3381 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3382 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3383 switch (dt)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3384 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3385 case oct_data_conv::dt_single:
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3386 retval = FloatNDArray (dims, static_cast <float> (val));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3387 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3388
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3389 case oct_data_conv::dt_double:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3390 retval = NDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3391 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3392
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3393 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3394 error ("%s: invalid class name", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3395 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3396 }
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 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3401 }
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 static octave_value
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3404 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	3405 const char *fcn)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3406 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3407 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3408
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3409 int nargin = args.length ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3410
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3411 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	3412
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3413 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3414
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3415 if (nargin > 0 && args(nargin-1).is_string ())
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3416 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3417 std::string nm = args(nargin-1).string_value ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3418 nargin--;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3419
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3420 dt = oct_data_conv::string_to_data_type (nm);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3421
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3422 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3423 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3424 }
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 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3427 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3428 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3429 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3430
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3431 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3432 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3433 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3434
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3435 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3436 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3437 dims.resize (nargin);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3438
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3439 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3440 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3441 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	3442
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3443 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3444 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3445 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3446 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3447 }
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 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3451 }
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 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3454 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3455 dims.chop_trailing_singletons ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3456
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3457 check_dimensions (dims, fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3458
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3459 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3460 // NDArray to scalar.
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3461
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3462 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3463 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3464 switch (dt)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3465 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3466 case oct_data_conv::dt_single:
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3467 retval = FloatComplexNDArray (dims, static_cast<FloatComplex> (val));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3468 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3469
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3470 case oct_data_conv::dt_double:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3471 retval = ComplexNDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3472 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3473
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3474 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3475 error ("%s: invalid class name", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3476 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3477 }
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 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3482 }
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 static octave_value
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3485 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	3486 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3487 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3488
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3489 int nargin = args.length ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3490
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3491 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3492
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3493 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3494 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3495 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3496 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3497
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3498 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3499 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3500 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3501
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3502 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3503 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3504 dims.resize (nargin);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3505
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3506 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3507 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3508 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	3509
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3510 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3511 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3512 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3513 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3514 }
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 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3518 }
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 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3521 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3522 dims.chop_trailing_singletons ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3523
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3524 check_dimensions (dims, fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3525
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3526 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3527 // NDArray to scalar.
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3528
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3529 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3530 retval = boolNDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3531 }
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 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3534 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3535
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3536 DEFUN (ones, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3537 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3538 @deftypefn {Built-in Function} {} ones (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3539 @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	3540 @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	3541 @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	3542 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	3543 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	3544 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3545 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	3546 use an expression like\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3547 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3548 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3549 val_matrix = val * ones (n, m)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3550 @end example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3551 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3552 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	3553 the specified type, for example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3554 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3555 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3556 val = ones (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3557 @end example\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3558 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3559 {
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3560 return fill_matrix (args, 1, "ones");
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3561 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3562
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3563 /*
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 %!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	3566 %!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	3567 %!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	3568 %!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	3569
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3570 %!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	3571 %!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	3572 %!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	3573 %!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	3574
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3575 %!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	3576 %!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	3577 %!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	3578 %!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	3579
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
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3582 DEFUN (zeros, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3583 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3584 @deftypefn {Built-in Function} {} zeros (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3585 @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	3586 @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	3587 @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	3588 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	3589 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	3590 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3591 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	3592 the specified type, for example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3593 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3594 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3595 val = zeros (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3596 @end example\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3597 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3598 {
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3599 return fill_matrix (args, 0, "zeros");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3600 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3601
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3602 /*
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 %!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	3605 %!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	3606 %!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	3607 %!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	3608
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3609 %!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	3610 %!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	3611 %!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	3612 %!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	3613
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3614 %!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	3615 %!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	3616 %!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	3617 %!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	3618
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
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3621 DEFUN (Inf, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3622 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3623 @deftypefn {Built-in Function} {} Inf (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3624 @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	3625 @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	3626 @deftypefnx {Built-in Function} {} Inf (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3627 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	3628 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	3629 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	3630 @samp{\"double\"}. The default is @samp{\"double\"}.\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3631 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3632 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3633 return fill_matrix (args, lo_ieee_inf_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3634 lo_ieee_float_inf_value (), "Inf");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3635 }
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 DEFALIAS (inf, Inf);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3638
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3639 /*
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 %!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	3642 %!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	3643 %!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	3644 %!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	3645
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3646 %!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	3647 %!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	3648 %!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	3649 %!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	3650
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3651 %!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	3652 %!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	3653 %!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	3654 %!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	3655
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
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3658 DEFUN (NaN, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3659 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3660 @deftypefn {Built-in Function} {} NaN (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3661 @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	3662 @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	3663 @deftypefnx {Built-in Function} {} NaN (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3664 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	3665 (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	3666 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3667 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3668 $0/0$, or $\\infty - \\infty$,\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3669 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3670 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3671 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3672 0/0, or @samp{Inf - Inf},\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3673 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3674 or any operation with a NaN.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3675 \n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3676 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	3677 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	3678 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	3679 \n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3680 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	3681 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	3682 @samp{\"double\"}. The default is @samp{\"double\"}.\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3683 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3684 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3685 return fill_matrix (args, lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3686 lo_ieee_float_nan_value (), "NaN");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3687 }
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 DEFALIAS (nan, NaN);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3690
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3691 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3692 %!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	3693 %!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	3694 %!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	3695 %!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	3696
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3697 %!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	3698 %!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	3699 %!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	3700 %!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	3701
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3702 %!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	3703 %!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	3704 %!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	3705 %!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	3706
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
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3709 DEFUN (e, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3710 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3711 @deftypefn {Built-in Function} {} e (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3712 @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	3713 @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	3714 @deftypefnx {Built-in Function} {} e (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3715 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	3716 to the base of natural logarithms. The constant\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3717 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3718 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3719 $e$\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3720 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3721 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3722 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3723 @var{e}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3724 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3725 satisfies the equation\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3726 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3727 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3728 $\\log (e) = 1$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3729 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3730 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3731 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3732 @code{log} (@var{e}) = 1.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3733 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3734 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3735 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3736 #if defined (M_E)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3737 double e_val = M_E;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3738 #else
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3739 double e_val = exp (1.0);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3740 #endif
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3741
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3742 return fill_matrix (args, e_val, "e");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3743 }
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 DEFUN (eps, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3746 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3747 @deftypefn {Built-in Function} {} eps (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3748 @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	3749 @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	3750 @deftypefnx {Built-in Function} {} eps (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3751 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	3752 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	3753 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	3754 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	3755 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	3756 is approximately\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3757 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3758 2.2204e-16.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3759 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3760 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3761 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3762 $2.2204\\times10^{-16}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3763 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3764 @end iftex\n\
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3765 for double precision and\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3766 @ifinfo\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3767 1.1921e-07.\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3768 @end ifinfo\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3769 @iftex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3770 @tex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3771 $1.1921\\times10^{-7}$.\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3772 @end tex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3773 @end iftex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3774 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	3775 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	3776 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3777 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3778 int nargin = args.length ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3779 octave_value retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3780
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3781 if (nargin == 1 && ! args(0).is_string ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3782 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3783 if (args(0).is_single_type ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3784 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3785 float val = args(0).float_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3786
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3787 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3788 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3789 val = ::fabsf(val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3790 if (xisnan (val) \|\| xisinf (val))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3791 retval = fill_matrix (octave_value ("single"),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3792 lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3793 lo_ieee_float_nan_value (), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3794 else if (val < FLT_MIN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3795 retval = fill_matrix (octave_value ("single"), 0e0,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3796 powf (2.0, -149e0), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3797 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3798 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3799 int expon;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3800 frexpf (val, &expon);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3801 val = std::pow (static_cast <float> (2.0),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3802 static_cast <float> (expon - 24));
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3803 retval = fill_matrix (octave_value ("single"), DBL_EPSILON,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3804 val, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3805 }
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 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3809 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3810 double val = args(0).double_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3811
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3812 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3813 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3814 val = ::fabs(val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3815 if (xisnan (val) \|\| xisinf (val))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3816 retval = fill_matrix (octave_value_list (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3817 lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3818 lo_ieee_float_nan_value (), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3819 else if (val < DBL_MIN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3820 retval = fill_matrix (octave_value_list (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3821 pow (2.0, -1074e0), 0e0, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3822 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3823 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3824 int expon;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3825 frexp (val, &expon);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3826 val = std::pow (static_cast <double> (2.0),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3827 static_cast <double> (expon - 53));
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3828 retval = fill_matrix (octave_value_list (), val,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3829 FLT_EPSILON, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3830 }
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 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3835 retval = fill_matrix (args, DBL_EPSILON, FLT_EPSILON, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3836
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3837 return retval;
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3838 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3839
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3840 /*
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 %!assert(eps(1/2),2^(-53))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3843 %!assert(eps(1),2^(-52))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3844 %!assert(eps(2),2^(-51))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3845 %!assert(eps(realmax),2^971)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3846 %!assert(eps(0),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3847 %!assert(eps(realmin/2),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3848 %!assert(eps(realmin/16),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3849 %!assert(eps(Inf),NaN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3850 %!assert(eps(NaN),NaN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3851 %!assert(eps(single(1/2)),single(2^(-24)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3852 %!assert(eps(single(1)),single(2^(-23)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3853 %!assert(eps(single(2)),single(2^(-22)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3854 %!assert(eps(realmax('single')),single(2^104))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3855 %!assert(eps(single(0)),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3856 %!assert(eps(realmin('single')/2),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3857 %!assert(eps(realmin('single')/16),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3858 %!assert(eps(single(Inf)),single(NaN))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3859 %!assert(eps(single(NaN)),single(NaN))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3860
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
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3864 DEFUN (pi, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3865 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3866 @deftypefn {Built-in Function} {} pi (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3867 @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	3868 @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	3869 @deftypefnx {Built-in Function} {} pi (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3870 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	3871 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	3872 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	3873 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3874 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3875 #if defined (M_PI)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3876 double pi_val = M_PI;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3877 #else
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3878 double pi_val = 4.0 * atan (1.0);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3879 #endif
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3880
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3881 return fill_matrix (args, pi_val, "pi");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3882 }
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 DEFUN (realmax, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3885 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3886 @deftypefn {Built-in Function} {} realmax (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3887 @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	3888 @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	3889 @deftypefnx {Built-in Function} {} realmax (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3890 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	3891 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	3892 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	3893 floating point arithmetic, @code{realmax} is approximately\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3894 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3895 1.7977e+308\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3896 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3897 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3898 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3899 $1.7977\\times10^{308}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3900 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3901 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3902 @seealso{realmin}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3903 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3904 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3905 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	3906 }
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 DEFUN (realmin, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3909 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3910 @deftypefn {Built-in Function} {} realmin (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3911 @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	3912 @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	3913 @deftypefnx {Built-in Function} {} realmin (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3914 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	3915 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	3916 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	3917 64-bit IEEE floating point arithmetic, @code{realmin} is approximately\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3918 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3919 2.2251e-308\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3920 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3921 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3922 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3923 $2.2251\\times10^{-308}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3924 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3925 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3926 @seealso{realmax}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3927 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3928 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3929 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	3930 }
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 DEFUN (I, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3933 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3934 @deftypefn {Built-in Function} {} I (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3935 @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	3936 @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	3937 @deftypefnx {Built-in Function} {} I (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3938 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	3939 to the pure imaginary unit, defined as\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3940 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3941 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3942 $\\sqrt{-1}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3943 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3944 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3945 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3946 @code{sqrt (-1)}.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3947 @end ifinfo\n\
7001 8b0cfeb06365 [project @ 2007-10-10 18:02:59 by jwe] jwe parents: 6999 diff changeset	3948 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	3949 other purposes.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3950 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3951 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3952 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	3953 }
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 DEFALIAS (i, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3956 DEFALIAS (J, 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
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3959 DEFUN (NA, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3960 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3961 @deftypefn {Built-in Function} {} NA (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3962 @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	3963 @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	3964 @deftypefnx {Built-in Function} {} NA (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3965 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	3966 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	3967 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3968 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3969 return fill_matrix (args, lo_ieee_na_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3970 lo_ieee_float_na_value (), "NA");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3971 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3972
7991 139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3973 /*
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 %!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	3976 %!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	3977
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
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3980 DEFUN (false, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3981 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3982 @deftypefn {Built-in Function} {} false (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3983 @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	3984 @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	3985 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	3986 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	3987 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3988 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3989 return fill_matrix (args, false, "false");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3990 }
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 DEFUN (true, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3993 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3994 @deftypefn {Built-in Function} {} true (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3995 @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	3996 @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	3997 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	3998 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	3999 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4000 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4001 return fill_matrix (args, true, "true");
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4002 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4003
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4004 template <class MT>
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4005 octave_value
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4006 identity_matrix (int nr, int nc)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4007 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4008 octave_value retval;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4009
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4010 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	4011
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4012 if (nr == 1 && nc == 1)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4013 retval = one;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4014 else
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4015 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4016 dim_vector dims (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4017
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4018 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	4019
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4020 MT m (dims, zero);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4021
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4022 if (nr > 0 && nc > 0)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4023 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4024 int n = std::min (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4025
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4026 for (int i = 0; i < n; i++)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4027 m(i,i) = one;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4028 }
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 retval = m;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4031 }
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 return retval;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4034 }
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4035
5058 11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4036 #define INSTANTIATE_EYE(T) \
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4037 template octave_value identity_matrix<T> (int, int)
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4038
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4039 INSTANTIATE_EYE (int8NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4040 INSTANTIATE_EYE (uint8NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4041 INSTANTIATE_EYE (int16NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4042 INSTANTIATE_EYE (uint16NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4043 INSTANTIATE_EYE (int32NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4044 INSTANTIATE_EYE (uint32NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4045 INSTANTIATE_EYE (int64NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4046 INSTANTIATE_EYE (uint64NDArray);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4047 INSTANTIATE_EYE (FloatNDArray);
5058 11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4048 INSTANTIATE_EYE (NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4049 INSTANTIATE_EYE (boolNDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4050
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4051 static octave_value
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4052 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	4053 {
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4054 octave_value retval;
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4055
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4056 // 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	4057 // 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	4058 // value.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4059
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4060 if (! error_state)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4061 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4062 switch (dt)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4063 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4064 case oct_data_conv::dt_int8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4065 retval = identity_matrix<int8NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4066 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4067
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4068 case oct_data_conv::dt_uint8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4069 retval = identity_matrix<uint8NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4070 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4071
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4072 case oct_data_conv::dt_int16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4073 retval = identity_matrix<int16NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4074 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4075
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4076 case oct_data_conv::dt_uint16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4077 retval = identity_matrix<uint16NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4078 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4079
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4080 case oct_data_conv::dt_int32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4081 retval = identity_matrix<int32NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4082 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4083
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4084 case oct_data_conv::dt_uint32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4085 retval = identity_matrix<uint32NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4086 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4087
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4088 case oct_data_conv::dt_int64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4089 retval = identity_matrix<int64NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4090 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4091
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4092 case oct_data_conv::dt_uint64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4093 retval = identity_matrix<uint64NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4094 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4095
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4096 case oct_data_conv::dt_single:
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	4097 retval = FloatDiagMatrix (nr, nc, 1.0f);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4098 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4099
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4100 case oct_data_conv::dt_double:
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	4101 retval = DiagMatrix (nr, nc, 1.0);
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4102 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4103
4986 fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4104 case oct_data_conv::dt_logical:
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4105 retval = identity_matrix<boolNDArray> (nr, nc);
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4106 break;
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4107
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4108 default:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4109 error ("eye: invalid class name");
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4110 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4111 }
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 return retval;
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4115 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4116
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4117 #undef INT_EYE_MATRIX
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4118
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	4119 DEFUN (eye, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4120 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4121 @deftypefn {Built-in Function} {} eye (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4122 @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	4123 @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	4124 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	4125 @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	4126 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	4127 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	4128 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	4129 respectively. For example,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4130 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4131 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4132 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4133 eye (3)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4134 @result{} 1 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4135 0 1 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4136 0 0 1\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4137 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4138 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4139 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4140 The following expressions all produce the same result:\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4141 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4142 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4143 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4144 eye (2)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4145 @equiv{}\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4146 eye (2, 2)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4147 @equiv{}\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4148 eye (size ([1, 2; 3, 4])\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4149 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4150 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4151 \n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4152 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	4153 the specified type, like\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4154 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4155 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4156 val = zeros (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4157 @end example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4158 \n\
6556 8810bbf321ce [project @ 2007-04-20 18:39:40 by jwe] jwe parents: 6518 diff changeset	4159 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	4160 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	4161 with @sc{Matlab}.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4162 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4163 {
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4164 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4165
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4166 int nargin = args.length ();
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4167
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4168 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	4169
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4170 // Check for type information.
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4171
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4172 if (nargin > 0 && args(nargin-1).is_string ())
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4173 {
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4174 std::string nm = args(nargin-1).string_value ();
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4175 nargin--;
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4176
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4177 dt = oct_data_conv::string_to_data_type (nm);
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4178
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4179 if (error_state)
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4180 return retval;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4181 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4182
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4183 switch (nargin)
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4184 {
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	4185 case 0:
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4186 retval = identity_matrix (1, 1, dt);
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	4187 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4188
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	4189 case 1:
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4190 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4191 octave_idx_type nr, nc;
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4192 get_dimensions (args(0), "eye", nr, nc);
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4193
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4194 if (! error_state)
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4195 retval = identity_matrix (nr, nc, dt);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4196 }
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	4197 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4198
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4199 case 2:
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4200 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4201 octave_idx_type nr, nc;
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4202 get_dimensions (args(0), args(1), "eye", nr, nc);
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4203
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4204 if (! error_state)
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4205 retval = identity_matrix (nr, nc, dt);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4206 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4207 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4208
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4209 default:
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4210 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4211 break;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4212 }
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 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4215 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4216
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4217
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
8459 d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4220 %!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	4221 %!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	4222
d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4223 %!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	4224 %!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	4225
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4226 %!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	4227 %!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	4228
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4229 %!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	4230
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
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	4233 DEFUN (linspace, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4234 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4235 @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	4236 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	4237 @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	4238 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	4239 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	4240 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	4241 value of 100 is used.\n\
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4242 \n\
4455 abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4358 diff changeset	4243 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	4244 \n\
0fcc8d65b571 [project @ 2007-05-16 15:32:09 by jwe] jwe parents: 6561 diff changeset	4245 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	4246 fewer than two values are requested.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4247 @end deftypefn")
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4248 {
3418 ca92c9d3f882 [project @ 2000-01-12 03:07:47 by jwe] jwe parents: 3373 diff changeset	4249 octave_value retval;
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4250
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4251 int nargin = args.length ();
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4252
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4253 octave_idx_type npoints = 100;
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4254
1940 1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4255 if (nargin != 2 && nargin != 3)
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4256 {
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4257 print_usage ();
1940 1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4258 return retval;
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4259 }
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4260
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4261 if (nargin == 3)
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4262 npoints = args(2).idx_type_value ();
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4263
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4264 if (! error_state)
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4265 {
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4266 octave_value arg_1 = args(0);
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4267 octave_value arg_2 = args(1);
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4268
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4269 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	4270 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4271 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	4272 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4273 FloatComplex x1 = arg_1.float_complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4274 FloatComplex x2 = arg_2.float_complex_value ();
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4275
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4276 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4277 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4278 FloatComplexRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4279
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4280 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4281 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4282 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4285 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4286 float x1 = arg_1.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4287 float x2 = arg_2.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4288
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4289 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4290 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4291 FloatRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4292
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4293 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4294 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4295 }
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4296 }
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 else
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4299 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4300 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	4301 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4302 Complex x1 = arg_1.complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4303 Complex x2 = arg_2.complex_value ();
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4304
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4305 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4306 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4307 ComplexRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4308
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4309 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4310 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4311 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4314 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4315 double x1 = arg_1.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4316 double x2 = arg_2.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4317
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4318 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4319 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4320 RowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4321
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4322 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4323 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4324 }
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4325 }
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4326 }
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4327 }
4732 b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	4328 else
b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	4329 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	4330
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4331 return retval;
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4332 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4333
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4334
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 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4338 %! 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	4339 %! 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	4340 %! 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	4341 %! 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	4342 %! && 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	4343 %! && 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	4344
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 % 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	4347
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4348 %!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	4349 %!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	4350
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4351 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4352 %! 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	4353
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
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4356 // 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	4357 // 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	4358
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4359 DEFUN (resize, args, ,
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4360 "-- texinfo --\n\
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4361 @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	4362 @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	4363 Destructively resize @var{x}.\n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4364 \n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4365 @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	4366 @code{reshape}.}\n\
6174 d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4367 \n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4368 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	4369 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	4370 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	4371 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	4372 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	4373 @seealso{reshape, postpad}\n\
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4374 @end deftypefn")
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4375 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4376 octave_value retval;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4377 int nargin = args.length ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4378
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4379 if (nargin == 2)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4380 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4381 Array<double> vec = args(1).vector_value ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4382 int ndim = vec.length ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4383 if (ndim == 1)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4384 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4385 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	4386 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4387 retval = retval.resize (dim_vector (m, m), true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4388 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4389 else
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4390 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4391 dim_vector dv;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4392 dv.resize (ndim);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4393 for (int i = 0; i < ndim; i++)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4394 dv(i) = static_cast<octave_idx_type> (vec(i));
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4395 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4396 retval = retval.resize (dv, true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4397 }
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 else if (nargin == 3)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4400 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4401 octave_idx_type m = static_cast<octave_idx_type>
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4402 (args(1).scalar_value());
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4403 octave_idx_type n = static_cast<octave_idx_type>
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4404 (args(2).scalar_value());
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4405 if (!error_state)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4406 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4407 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4408 retval = retval.resize (dim_vector (m, n), true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4409 }
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 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4412 print_usage ();
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4413 return retval;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4414 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4415
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4416 // FIXME -- should use octave_idx_type for dimensions.
5734 a7d2c47371d2 [project @ 2006-04-04 18:29:13 by jwe] jwe parents: 5731 diff changeset	4417
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4418 DEFUN (reshape, args, ,
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4419 "-- texinfo --\n\
6671 9042b00fc45e [project @ 2007-05-30 06:33:29 by jwe] jwe parents: 6630 diff changeset	4420 @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	4421 @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	4422 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	4423 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	4424 column-major order (like Fortran arrays are stored).\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4425 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4426 For example,\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4427 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4428 @example\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4429 @group\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4430 reshape ([1, 2, 3, 4], 2, 2)\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4431 @result{} 1 3\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4432 2 4\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4433 @end group\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4434 @end example\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4435 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4436 @noindent\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4437 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	4438 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	4439 \n\
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4440 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	4441 by an empty argument.\n\
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4442 @end deftypefn")
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4443 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4444 octave_value retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4445
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4446 int nargin = args.length ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4447
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4448 Array<int> new_size;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4449
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4450 if (nargin == 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4451 new_size = args(1).int_vector_value ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4452 else if (nargin > 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4453 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4454 new_size.resize (nargin-1);
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4455 int empty_dim = -1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4456
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4457 for (int i = 1; i < nargin; i++)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4458 {
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4459 if (args(i).is_empty ())
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4460 if (empty_dim > 0)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4461 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4462 error ("reshape: only a single dimension can be unknown");
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4463 break;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4464 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4465 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4466 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4467 empty_dim = i;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4468 new_size(i-1) = 1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4469 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4470 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4471 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4472 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	4473
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4474 if (error_state)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4475 break;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4476 }
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 if (! error_state && (empty_dim > 0))
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4480 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4481 int nel = 1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4482 for (int i = 0; i < nargin - 1; i++)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4483 nel *= new_size(i);
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4484
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4485 if (nel == 0)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4486 new_size(empty_dim-1) = 0;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4487 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4488 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4489 int size_empty_dim = args(0).numel () / nel;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4490
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4491 if (args(0).numel () != size_empty_dim * nel)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4492 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	4493 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4494 new_size(empty_dim-1) = size_empty_dim;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4495 }
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4496 }
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 else
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4499 {
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4500 print_usage ();
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4501 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4502 }
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 if (error_state)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4505 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4506 error ("reshape: invalid arguments");
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4507 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4508 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4509
4739 7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4510 // 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	4511 // elements.
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4512
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4513 int n = new_size.length ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4514
4739 7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4515 while (n > 2)
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4516 {
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4517 if (new_size(n-1) == 1)
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4518 n--;
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4519 else
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4520 break;
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4521 }
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 new_size.resize (n);
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4524
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4525 if (n < 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4526 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4527 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	4528 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4529 }
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 dim_vector new_dims;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4532
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4533 new_dims.resize (n);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4534
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4535 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	4536 new_dims(i) = new_size(i);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4537
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4538 octave_value arg = args(0);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4539
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4540 if (new_dims.numel () == arg.numel ())
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4541 retval = (new_dims == arg.dims ()) ? arg : arg.reshape (new_dims);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4542 else
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4543 error ("reshape: size mismatch");
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4544
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4545 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4546 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4547
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4548 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4549
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4550 %!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	4551 %!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	4552 %!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	4553 %!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	4554
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4555 %!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	4556 %!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	4557 %!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	4558 %!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	4559
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4560 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4561 %! 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	4562 %! 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	4563
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4564 %!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	4565 %!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	4566
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4567 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4568
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4569 DEFUN (squeeze, args, ,
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4570 "-- texinfo --\n\
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4571 @deftypefn {Built-in Function} {} squeeze (@var{x})\n\
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4572 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	4573 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	4574 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	4575 @end deftypefn")
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4576 {
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4577 octave_value retval;
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4578
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4579 if (args.length () == 1)
4545 c16f153836a0 [project @ 2003-10-24 04:45:45 by jwe] jwe parents: 4532 diff changeset	4580 retval = args(0).squeeze ();
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4581 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4582 print_usage ();
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4583
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4584 return retval;
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
8458 d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4587 DEFUN (full, args, ,
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4588 "-- texinfo --\n\
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4589 @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	4590 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	4591 @seealso{sparse}\n\
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4592 @end deftypefn")
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4593 {
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4594 octave_value retval;
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4595
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4596 if (args.length () == 1)
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4597 retval = args(0).full_value ();
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4598 else
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4599 print_usage ();
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4600
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4601 return retval;
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
6945 6bbf56a9718a [project @ 2007-10-02 20:47:22 by jwe] jwe parents: 6887 diff changeset	4604 // Compute various norms of the vector X.
6bbf56a9718a [project @ 2007-10-02 20:47:22 by jwe] jwe parents: 6887 diff changeset	4605
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4606 DEFUN (norm, args, ,
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4607 "-- texinfo --\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4608 @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	4609 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	4610 missing, @code{p = 2} is assumed.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4611 \n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4612 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	4613 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4614 @table @asis\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4615 @item @var{p} = @code{1}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4616 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	4617 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4618 @item @var{p} = @code{2}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4619 Largest singular value of @var{a}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4620 \n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4621 @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	4622 @cindex infinity norm\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4623 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	4624 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4625 @item @var{p} = @code{\"fro\"}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4626 @cindex Frobenius norm\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4627 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	4628 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4629 @item other @var{p}, @code{@var{p} > 1}\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4630 @cindex general p-norm \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4631 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	4632 @end table\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 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	4635 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4636 @table @asis\n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4637 @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	4638 @code{max (abs (@var{a}))}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4639 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4640 @item @var{p} = @code{-Inf}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4641 @code{min (abs (@var{a}))}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4642 \n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4643 @item @var{p} = @code{\"fro\"}\n\
e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4644 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	4645 \n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4646 @item @var{p} = 0\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4647 Hamming norm - the number of nonzero elements.\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4648 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4649 @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	4650 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	4651 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4652 @item other @var{p} @code{@var{p} < 1}\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4653 the p-pseudonorm defined as above.\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4654 @end table\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4655 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4656 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	4657 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	4658 column norms are computed.\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4659 @seealso{cond, svd}\n\
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4660 @end deftypefn")
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4661 {
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4662 octave_value_list retval;
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4663
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4664 int nargin = args.length ();
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4665
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4666 if (nargin >= 1 && nargin <= 3)
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4667 {
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4668 octave_value x_arg = args(0);
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4669
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4670 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	4671 {
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4672 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	4673 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	4674 else
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4675 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	4676 }
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4677 else if (x_arg.ndims () == 2)
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4678 {
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4679 enum { sfmatrix, sfcols, sfrows, sffrob, sfinf } strflag = sfmatrix;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4680 if (nargin > 1 && args(nargin-1).is_string ())
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4681 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4682 std::string str = args(nargin-1).string_value ();
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4683 if (str == "cols" \|\| str == "columns")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4684 strflag = sfcols;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4685 else if (str == "rows")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4686 strflag = sfrows;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4687 else if (str == "fro")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4688 strflag = sffrob;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4689 else if (str == "inf")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4690 strflag = sfinf;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4691 else
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4692 error ("norm: unrecognized option: %s", str.c_str ());
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4693 // 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	4694 nargin --;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4695 }
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4696 else if (nargin > 1 && ! args(1).is_scalar_type ())
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4697 gripe_wrong_type_arg ("norm", args(1), true);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4698
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4699 if (! error_state)
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4700 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4701 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	4702 switch (strflag)
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4703 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4704 case sfmatrix:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4705 retval(0) = xnorm (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4706 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4707 case sfcols:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4708 retval(0) = xcolnorms (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4709 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4710 case sfrows:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4711 retval(0) = xrownorms (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4712 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4713 case sffrob:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4714 retval(0) = xfrobnorm (x_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 sfinf:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4717 retval(0) = xnorm (x_arg, octave_Inf);
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 }
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4720 }
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4721 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4722 else
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4723 error ("norm: only valid for 2-D objects");
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4724 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4725 else
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4726 print_usage ();
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4727
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4728 return retval;
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4729 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4730
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4731 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4732 %!shared x
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4733 %! 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	4734 %!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	4735 %!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	4736 %!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	4737 %!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	4738 %!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	4739 %!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	4740 %!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	4741 %!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	4742 %!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	4743 %!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	4744 %!shared m
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4745 %! 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	4746 %!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	4747 %!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	4748 %!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	4749 %!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	4750 %!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	4751 %! 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	4752 %! 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	4753 %! 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	4754 %!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	4755 %!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	4756
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4757 %!shared x
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4758 %! 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	4759 %!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	4760 %!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	4761 %!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	4762 %!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	4763 %!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	4764 %!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	4765 %!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	4766 %!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	4767 %!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	4768 %!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	4769 %!shared m
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4770 %! 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	4771 %!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	4772 %!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	4773 %!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	4774 %!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	4775 %!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	4776 %! 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	4777 %! 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	4778 %! 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	4779 %!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	4780 %!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	4781 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4782
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4783 #define UNARY_OP_DEFUN_BODY(F) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4784 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4785 octave_value retval; \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4786 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4787 if (args.length () == 1) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4788 retval = F (args(0)); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4789 else \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4790 print_usage (); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4791 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4792 return retval
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 DEFUN (not, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4795 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4796 @deftypefn {Built-in Function} {} not (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4797 This function is equivalent to @code{! x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4798 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4799 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4800 UNARY_OP_DEFUN_BODY (op_not);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4801 }
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 (uplus, 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} {} uplus (@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_uplus);
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 (uminus, 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} {} uminus (@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_uminus);
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 (transpose, 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} {} transpose (@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_transpose);
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
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4830 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4831
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4832 %!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	4833 %!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	4834 %!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	4835 %!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	4836 %!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	4837 %!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	4838
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4839 %!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	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 (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	4842 %!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	4843 %!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	4844 %!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	4845 %!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	4846 %!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	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 (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	4849
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4850 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4851
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4852 DEFUN (ctranspose, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4853 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4854 @deftypefn {Built-in Function} {} ctranspose (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4855 This function is equivalent to @code{x'}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4856 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4857 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4858 UNARY_OP_DEFUN_BODY (op_hermitian);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4859 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4860
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4861 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4862
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4863 %!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	4864 %!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	4865 %!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	4866 %!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	4867 %!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	4868 %!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	4869
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4870 %!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	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 (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	4873 %!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	4874 %!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	4875 %!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	4876 %!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	4877 %!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	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 (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	4880
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4881 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4882
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4883 #define BINARY_OP_DEFUN_BODY(F) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4884 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4885 octave_value retval; \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4886 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4887 if (args.length () == 2) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4888 retval = F (args(0), args(1)); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4889 else \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4890 print_usage (); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4891 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4892 return retval
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 DEFUN (plus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4895 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4896 @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	4897 This function is equivalent to @code{x + y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4898 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4899 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4900 BINARY_OP_DEFUN_BODY (op_add);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4901 }
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 (minus, 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} {} minus (@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_sub);
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 (mtimes, 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} {} mtimes (@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_mul);
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 (mrdivide, 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} {} mrdivide (@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_div);
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 (mpower, 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} {} mpower (@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_pow);
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 (mldivide, 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} {} mldivide (@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_ldiv);
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 (lt, 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} {} lt (@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_lt);
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 (le, 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} {} le (@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_le);
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 (eq, 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} {} eq (@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_eq);
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 (ge, 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} {} ge (@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_ge);
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 (gt, 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} {} gt (@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_gt);
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 (ne, 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} {} ne (@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_ne);
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 (times, 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} {} times (@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_el_mul);
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 (rdivide, 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} {} rdivide (@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_div);
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 (power, 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} {} power (@var{x}, @var{y})\n\
7623 431f3788f5c4 minor doc patch David Bateman <dbateman@free.fr> parents: 7620 diff changeset	5023 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	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_pow);
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 (ldivide, 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} {} ldivide (@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_ldiv);
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 (and, 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} {} and (@var{x}, @var{y})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5041 This function is equivalent to @code{x & y}.\n\
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_and);
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 (or, 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} {} or (@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_or);
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
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5056 static double tic_toc_timestamp = -1.0;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5057
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5058 DEFUN (tic, args, nargout,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5059 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5060 @deftypefn {Built-in Function} {} tic ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5061 @deftypefnx {Built-in Function} {} toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5062 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	5063 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	5064 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	5065 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5066 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5067 tic ();\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5068 # many computations later...\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5069 elapsed_time = toc ();\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5070 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5071 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5072 @noindent\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5073 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	5074 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	5075 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5076 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	5077 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	5078 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5079 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5080 @group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5081 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	5082 @result{} 5\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5083 @end group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5084 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5085 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5086 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	5087 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	5088 recent call to @code{tic}.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5089 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5090 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	5091 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	5092 @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	5093 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	5094 doing nothing at all. For example,\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5095 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5096 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5097 @group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5098 tic (); sleep (5); toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5099 @result{} 5\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5100 t = cputime (); sleep (5); cputime () - t\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5101 @result{} 0\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5102 @end group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5103 @end 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 @noindent\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5106 (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	5107 coarse resolution.)\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5108 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5109 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5110 octave_value retval;
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5111
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5112 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5113
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5114 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5115 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5116
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5117 octave_time now;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5118
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5119 double tmp = now.double_value ();
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 if (nargout > 0)
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5122 retval = static_cast<octave_uint64> (1e6 * tmp);
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5123 else
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5124 tic_toc_timestamp = tmp;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5125
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5126 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5127 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5128
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5129 DEFUN (toc, args, nargout,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5130 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5131 @deftypefn {Built-in Function} {} toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5132 See tic.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5133 @end deftypefn")
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 octave_value retval;
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5136
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5137 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5138
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5139 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5140 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5141
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5142 if (tic_toc_timestamp < 0)
7045 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 warning ("toc called before timer set");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5145 if (nargout > 0)
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5146 retval = Matrix ();
7045 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 else
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5149 {
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5150 octave_time now;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5151
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5152 double tmp = now.double_value () - tic_toc_timestamp;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5153
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5154 if (nargout > 0)
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5155 retval = tmp;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5156 else
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5157 octave_stdout << "Elapsed time is " << tmp << " seconds.\n";
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5158 }
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5159
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5160 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5161 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5162
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5163 DEFUN (cputime, args, ,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5164 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5165 @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	5166 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	5167 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	5168 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	5169 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	5170 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	5171 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	5172 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	5173 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	5174 CPU time used is nonzero.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5175 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5176 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5177 octave_value_list retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5178 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5179 double usr = 0.0;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5180 double sys = 0.0;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5181
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5182 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5183 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5184
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5185 #if defined (HAVE_GETRUSAGE)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5186
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5187 struct rusage ru;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5188
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5189 getrusage (RUSAGE_SELF, &ru);
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 usr = static_cast<double> (ru.ru_utime.tv_sec) +
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5192 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	5193
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5194 sys = static_cast<double> (ru.ru_stime.tv_sec) +
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5195 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	5196
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5197 #elif defined (HAVE_TIMES) && defined (HAVE_SYS_TIMES_H)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5198
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5199 struct tms t;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5200
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5201 times (&t);
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 unsigned long ticks;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5204 unsigned long seconds;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5205 unsigned long fraction;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5206
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5207 ticks = t.tms_utime + t.tms_cutime;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5208 fraction = ticks % HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5209 seconds = ticks / HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5210
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5211 usr = static_cast<double> (seconds) + static_cast<double>(fraction) /
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5212 static_cast<double>(HZ);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5213
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5214 ticks = t.tms_stime + t.tms_cstime;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5215 fraction = ticks % HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5216 seconds = ticks / HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5217
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5218 sys = static_cast<double> (seconds) + static_cast<double>(fraction) /
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5219 static_cast<double>(HZ);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5220
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5221 #elif defined (__WIN32__)
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5222
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5223 HANDLE hProcess = GetCurrentProcess ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5224 FILETIME ftCreation, ftExit, ftUser, ftKernel;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5225 GetProcessTimes (hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser);
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 int64_t itmp = (reinterpret_cast<int64_t > (&ftUser));
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5228 usr = static_cast<double> (itmp) * 1e-7;
7045 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 itmp = (reinterpret_cast<int64_t > (&ftKernel));
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5231 sys = static_cast<double> (itmp) * 1e-7;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5232
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5233 #endif
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5234
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5235 retval (2) = sys;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5236 retval (1) = usr;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5237 retval (0) = sys + usr;
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 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5240 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5241
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5242 DEFUN (sort, args, nargout,
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5243 "-- texinfo --\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5244 @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	5245 @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	5246 @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	5247 @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	5248 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	5249 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	5250 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5251 For example,\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5252 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5253 @example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5254 @group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5255 sort ([1, 2; 2, 3; 3, 1])\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5256 @result{} 1 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5257 2 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5258 3 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5259 @end group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5260 @end 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 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	5263 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	5264 matrix. For example,\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5265 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5266 @example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5267 @group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5268 [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	5269 @result{} s = 1 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5270 2 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5271 3 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5272 @result{} i = 1 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5273 2 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5274 3 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5275 @end group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5276 @end example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5277 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5278 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	5279 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	5280 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	5281 @code{mode} are `ascend' or `descend'.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5282 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5283 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	5284 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	5285 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5286 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	5287 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	5288 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5289 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	5290 ordered lists.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5291 @end deftypefn")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5292 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5293 octave_value_list retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5294
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5295 int nargin = args.length ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5296 sortmode smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5297
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5298 if (nargin < 1 \|\| nargin > 3)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5299 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5300 print_usage ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5301 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5302 }
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 bool return_idx = nargout > 1;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5305
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5306 octave_value arg = args(0);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5307
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5308 int dim = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5309 if (nargin > 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5310 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5311 if (args(1).is_string ())
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 std::string mode = args(1).string_value();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5314 if (mode == "ascend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5315 smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5316 else if (mode == "descend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5317 smode = DESCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5318 else
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 error ("sort: mode must be either \"ascend\" or \"descend\"");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5321 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5322 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5323 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5324 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5325 dim = args(1).nint_value () - 1;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5326 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5327
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5328 if (nargin > 2)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5329 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5330 if (args(1).is_string ())
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 print_usage ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5333 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5334 }
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 if (! args(2).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5337 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5338 error ("sort: mode must be a string");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5339 return retval;
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 std::string mode = args(2).string_value();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5342 if (mode == "ascend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5343 smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5344 else if (mode == "descend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5345 smode = DESCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5346 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5347 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5348 error ("sort: mode must be either \"ascend\" or \"descend\"");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5349 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5350 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5351 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5352
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5353 dim_vector dv = arg.dims ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5354 if (error_state)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5355 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5356 gripe_wrong_type_arg ("sort", arg);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5357 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5358 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5359 if (nargin == 1 \|\| args(1).is_string ())
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 // Find first non singleton dimension
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5362 for (int i = 0; i < dv.length (); i++)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5363 if (dv(i) > 1)
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 dim = i;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5366 break;
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 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5369 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5370 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5371 if (dim < 0 \|\| dim > dv.length () - 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5372 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5373 error ("sort: dim must be a valid dimension");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5374 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5375 }
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 if (return_idx)
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 Array<octave_idx_type> sidx;
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 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	5383 retval (1) = NDArray (sidx, true);
7433 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 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5386 retval(0) = arg.sort (dim, smode);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5387
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5388 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5389 }
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 /*
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5392
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5393 %% Double
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5394 %!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	5395 %!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	5396 %!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	5397 %!error (sort ([NaN, 1, -1, 2, Inf], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5398 %!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	5399 %!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	5400 %!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	5401 %!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	5402 %!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	5403 %!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	5404 %!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	5405 %!assert (sort (1), 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5406
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5407 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5408 %! [v, i] = sort ([NaN, 1, -1, Inf, 1]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5409 %! assert (v, [-1, 1, 1, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5410 %! assert (i, [3, 2, 5, 4, 1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5411
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5412 %% Complex
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5413 %!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	5414 %!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	5415 %!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	5416 %!error (sort ([NaN, 1i, -1, 2, Inf], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5417 %!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	5418 %!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	5419 %!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	5420 %!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	5421 %!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	5422 %!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	5423 %!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	5424 %!assert (sort (1i), 1i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5425
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5426 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5427 %! [v, i] = sort ([NaN, 1i, -1, Inf, 1, 1i]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5428 %! assert (v, [1, 1i, 1i, -1, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5429 %! assert (i, [5, 2, 6, 3, 4, 1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5430
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5431 %% Single
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5432 %!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	5433 %!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	5434 %!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	5435 %!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	5436 %!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	5437 %!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	5438 %!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	5439 %!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	5440 %!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	5441 %!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	5442 %!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	5443 %!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	5444
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5445 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5446 %! [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	5447 %! 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	5448 %! 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	5449
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5450 %% Single Complex
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([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	5452 %!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	5453 %!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	5454 %!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	5455 %!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	5456 %!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	5457 %!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	5458 %!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	5459 %!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	5460 %!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	5461 %!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	5462 %!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	5463
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5464 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5465 %! [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	5466 %! 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	5467 %! 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	5468
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5469 %% Bool
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5470 %!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	5471 %!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	5472 %!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	5473 %!error (sort ([true, false, true, false], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5474 %!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	5475 %!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	5476 %!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	5477 %!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	5478 %!assert (sort (true), true)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5479
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5480 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5481 %! [v, i] = sort ([true, false, true, false]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5482 %! assert (v, [false, false, true, true])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5483 %! assert (i, [2, 4, 1, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5484
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5485 %% Sparse Double
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5486 %!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	5487 %!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	5488 %!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	5489 %!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	5490 %!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	5491 %!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	5492 %!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	5493 %!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	5494
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5495 %!shared a
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5496 %! a = randn (10, 10);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5497 %! a (a < 0) = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5498 %!assert (sort (sparse (a)), sparse (sort (a)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5499 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5500 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5501 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5502 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5503 %! [vs, is] = sort (sparse (a));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5504 %! assert (vs, sparse (v))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5505 %! assert (is, i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5506
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5507 %% Sparse Complex
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5508 %!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	5509 %!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	5510 %!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	5511 %!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	5512 %!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	5513 %!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	5514 %!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	5515 %!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	5516
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5517 %!shared a
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5518 %! a = randn (10, 10);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5519 %! a (a < 0) = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5520 %! a = 1i * a;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5521 %!assert (sort (sparse (a)), sparse (sort (a)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5522 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5523 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5524 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5525 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5526 %! [vs, is] = sort (sparse (a));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5527 %! assert (vs, sparse (v))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5528 %! assert (is, i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5529
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5530 %% Sparse Bool
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5531 %!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	5532 %!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	5533 %!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	5534 %!error (sort (sparse ([true, false, true, false], 3)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5535 %!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	5536 %!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	5537 %!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	5538 %!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	5539
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5540 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5541 %! [v, i] = sort (sparse([true, false, true, false]));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5542 %! assert (v, sparse([false, false, true, true]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5543 %! assert (i, [2, 4, 1, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5544
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5545 %% Cell string array
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5546 %!shared a, b, c
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5547 %! a = {"Alice", "Cecile", "Eric", "Barry", "David"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5548 %! b = {"Alice", "Barry", "Cecile", "David", "Eric"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5549 %! c = {"Eric", "David", "Cecile", "Barry", "Alice"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5550 %!assert (sort (a), b);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5551 %!assert (sort (a, 1), a)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5552 %!assert (sort (a, 2), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5553 %!error (sort (a, 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5554 %!assert (sort (a, "ascend"), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5555 %!assert (sort (a, 2, "ascend"), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5556 %!assert (sort (a, "descend"), c)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5557 %!assert (sort (a, 2, "descend"), c)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5558
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5559 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5560 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5561 %! assert (i, [1, 4, 2, 5, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5562
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5563 %!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	5564 %!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	5565
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5566 */
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5567
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5568 /*
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5569 ;;; Local Variables: ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5570 ;;; mode: C++ ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5571 ;;; End: ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5572 */

Mercurial > hg > octave-lyh

annotate src/data.cc @ 8487:5701c2fe3327