octave-avbm: src/data.cc annotate

annotate src/data.cc @ 8129:5d56d4fb6abd

Merge problem with previous patch to Fcat

author	David Bateman <dbateman@free.fr>
date	Mon, 22 Sep 2008 13:37:05 -0400
parents	38a797766a2a
children	6f2d95255911

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"
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	65
7914 e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	66 #if ! defined (HAVE_HYPOTF) && defined (HAVE__HYPOTF)
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	67 #define hypotf _hypotf
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	68 #define HAVE_HYPOTF 1
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	69 #endif
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	70
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	71 #define ANY_ALL(FCN) \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	72 \
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	73 octave_value retval; \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	74 \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	75 int nargin = args.length (); \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	76 \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	77 if (nargin == 1 \|\| nargin == 2) \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	78 { \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	79 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	80 \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	81 if (! error_state) \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	82 { \
4556 773a21e4fce8 [project @ 2003-10-28 05:02:10 by jwe] jwe parents: 4554 diff changeset	83 if (dim >= -1) \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	84 retval = args(0).FCN (dim); \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	85 else \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	86 error (#FCN ": invalid dimension argument = %d", dim + 1); \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	87 } \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	88 else \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	89 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	90 } \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	91 else \
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	92 print_usage (); \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	93 \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	94 return retval
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	95
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	96 DEFUN (all, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	97 "-- texinfo --\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	98 @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	99 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	100 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	101 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	102 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	103 {
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	104 ANY_ALL (all);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	105 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	106
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	107 /*
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 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	110 %! 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	111 %! 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	112 %! 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	113 %! && 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	114 %! && 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	115 %! && 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	116
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	117 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	118 %! 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	119 %! 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	120 %! 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	121 %! && 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	122 %! && 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	123 %! && 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	124
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	125 %!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	126 %!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	127
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
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	130 DEFUN (any, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	131 "-- texinfo --\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	132 @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	133 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	134 nonzero.\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	135 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	136 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	137 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	138 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	139 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	140 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	141 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	142 any (eye (2, 4))\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	143 @result{} [ 1, 1, 0, 0 ]\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	144 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	145 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	146 \n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	147 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	148 @var{dim}. For example,\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	149 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	150 @example\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	151 @group\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	152 any (eye (2, 4), 2)\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	153 @result{} [ 1; 1 ]\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	154 @end group\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	155 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	156 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	157 {
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	158 ANY_ALL (any);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	159 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	160
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	161 /*
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 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	164 %! 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	165 %! 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	166 %! 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	167 %! && 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	168 %! && 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	169 %! && 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	170
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	171 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	172 %! 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	173 %! 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	174 %! 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	175 %! && 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	176 %! && 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	177 %! && 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	178
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	179 %!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	180 %!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	181
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
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	184 // 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	185
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	186 typedef double (*d_dd_fcn) (double, double);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	187 typedef float (*f_ff_fcn) (float, float);
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	188
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	189 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	190 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	191 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	192 NDArray retval (y.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	193 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	194
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	195 const double *y_data = y.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	196
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	197 octave_idx_type nel = y.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	198
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	199 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	200 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	201 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	202 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	203 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	204
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	205 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	206 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	207
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	208 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	209 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	210 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	211 FloatNDArray retval (y.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	212 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	213
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	214 const float *y_data = y.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	215
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	216 octave_idx_type nel = y.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	217
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	218 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	219 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	220 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	221 r_data[i] = f (x, y_data[i]);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	222 }
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 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	225 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	226
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	227 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	228 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	229 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	230 NDArray retval (x.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	231 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	232
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	233 const double *x_data = x.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	234
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	235 octave_idx_type nel = x.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	236
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	237 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	238 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	239 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	240 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	241 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	242
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	243 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	244 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	245
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	246 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	247 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	248 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	249 FloatNDArray retval (x.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	250 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	251
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	252 const float *x_data = x.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	253
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	254 octave_idx_type nel = x.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	255
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	256 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	257 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	258 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	259 r_data[i] = f (x_data[i], y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	260 }
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 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	263 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	264
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	265 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	266 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	267 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	268 assert (x.dims () == y.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	269
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	270 NDArray retval (x.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	271 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	272
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	273 const double *x_data = x.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	274 const double *y_data = y.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	275
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	276 octave_idx_type nel = x.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	277
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	278 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	279 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	280 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	281 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	282 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	283
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	284 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	285 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	286
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	287 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	288 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	289 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	290 assert (x.dims () == y.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	291
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	292 FloatNDArray retval (x.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	293 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	294
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	295 const float *x_data = x.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	296 const float *y_data = y.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	297
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	298 octave_idx_type nel = x.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	299
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	300 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	301 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	302 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	303 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	304 }
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 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	307 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	308
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	309 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	310 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	311 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	312 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	313 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	314 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	315 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	316
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	317 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	318 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	319 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	320
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	321 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	322 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	323 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	324 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	325 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	326 }
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 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	329 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	330 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	331 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	332 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	333 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	334 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	335 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	336
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	337 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	338 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	339 for (octave_idx_type 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	340 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	341 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	342 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	343
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	344 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	345 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	346 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	347 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	348 }
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 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	351 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	352
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	353 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	354 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	355
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	356 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	357 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	358
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	359 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	360 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	361 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	362 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	363 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	364 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	365 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	366
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	367 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	368 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	369 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	370
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	371 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	372 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	373 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	374 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	375 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	376 }
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 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	379 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	380 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	381 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	382 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	383 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	384 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	385 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	386
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	387 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	388 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	389 for (octave_idx_type 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	390 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	391 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	392 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	393
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	394 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	395 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	396 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	397 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	398 }
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 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	401 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	402
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	403 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	404 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	405
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	406 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	407 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	408
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	409 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	410 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	411 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	412 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	413 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	414
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	415 octave_idx_type 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	416 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	417
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	418 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	419
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	420 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	421 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	422
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	423 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	424 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	425 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	426 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	427
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	428 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	429 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	430 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	431 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	432 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	433 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	434 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	435 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	436 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 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	438 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	439 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	440 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	441 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	442 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	443 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	444 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	445 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	446 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	447
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	448 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	449 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	450 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	451 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	452 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	453 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	454 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	455 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	456 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 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	458 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	459 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	460 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	461 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	462 k2++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	463 }
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 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	469 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	470 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	471 {
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	472 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	473 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	474 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	475 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	476 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	477
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	478 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	479 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	480 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	481 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	482 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	483 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	484 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	485 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	486 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	487 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	488 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	489 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	490 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	491 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	492 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	493 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	494 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	495 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	496 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	497 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	498 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	499
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	500 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	501 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	502 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	503 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	504 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	505 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	506 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	507 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	508 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	509 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	510 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	511 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	512 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	513 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	514 }
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 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	517 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	518 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	519 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	520 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	521 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	522 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	523 }
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 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	526 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	527
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	528 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	529 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	530
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	531 DEFUN (atan2, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	532 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	533 @deftypefn {Mapping Function} {} atan2 (@var{y}, @var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	534 Compute atan (@var{y} / @var{x}) for corresponding elements of @var{y}\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	535 and @var{x}. The result is in range -pi to pi.\n\
3439 3234a698073a [project @ 2000-01-14 09:51:14 by jwe] jwe parents: 3428 diff changeset	536 @end deftypefn")
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	537 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	538 octave_value retval;
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	539
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	540 int nargin = args.length ();
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	541
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	542 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	543 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	544 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	545 error ("atan2: not defined for integer types");
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	546 else
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	547 {
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	548 octave_value arg_y = args(0);
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	549 octave_value arg_x = args(1);
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	550
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	551 dim_vector y_dims = arg_y.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	552 dim_vector x_dims = arg_x.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	553
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	554 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	555 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	556
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	557 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	558
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	559 if (y_is_scalar && x_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	560 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	561 if (is_float)
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	562 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	563 float y = arg_y.float_value ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	564
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	565 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	566 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	567 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	568
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	569 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	570 retval = atan2f (y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	571 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	574 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	575 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	576
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	577 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	578 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	579 double x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	580
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	581 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	582 retval = atan2 (y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	583 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	584 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	585 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	586 else if (y_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	587 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	588 if (is_float)
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	589 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	590 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	591
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	592 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	593 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	594 // 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	595 FloatNDArray x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	596
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	597 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	598 retval = map_f_fm (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	599 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	602 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	603 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	604
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	605 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	606 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	607 // 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	608 NDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	609
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	610 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	611 retval = map_d_m (atan2, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	612 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	613 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	614 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	615 else if (x_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	616 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	617 if (arg_y.is_sparse_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	618 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	619 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	620
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	621 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	622 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	623 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	624
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	625 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	626 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	627 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	628 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	629 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	630 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	631 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	632
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	633 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	634 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	635 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	636
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	637 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	638 retval = map_fm_f (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	639 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	640 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	641 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	642 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	643 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	644
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	645 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	646 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	647 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	648
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	649 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	650 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	651 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	652 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	653 }
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	654 else if (y_dims == x_dims)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	655 {
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	656 // 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	657 if (arg_x.is_sparse_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	658 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	659 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	660
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	661 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	662 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	663 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	664
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	665 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	666 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	667 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	668 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	669 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	670 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	671 FloatNDArray y = arg_y.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	672
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	673 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	674 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	675 FloatNDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	676
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	677 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	678 retval = map_fm_fm (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	679 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	680 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	681 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	682 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	683 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	684
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	685 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	686 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	687 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	688
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	689 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	690 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	691 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	692 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	693 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	694 else
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	695 error ("atan2: nonconformant matrices");
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	696 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	697 }
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	698 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	699 print_usage ();
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	700
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	701 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	702 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	703
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	704 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	705 %!assert (size (atan2 (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	706 %!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	707 %!assert (size (atan2 (rand (2, 3, 4), 1)), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	708 %!assert (size (atan2 (1, rand (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	709 %!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	710
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	711 %!test
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	712 %! rt2 = sqrt (2);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	713 %! rt3 = sqrt (3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	714 %! 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	715 %! 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	716 %! 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	717 %! 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	718
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	719 %!test
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	720 %! rt2 = sqrt (2);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	721 %! rt3 = sqrt (3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	722 %! 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	723 %! 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	724 %! 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	725 %! 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	726
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	727 %!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	728 %!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	729
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	730 */
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	731
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	732
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	733
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	734 DEFUN (hypot, args, ,
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	735 "-- texinfo --\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	736 @deftypefn {Mapping Function} {} hypot (@var{x}, @var{y})\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	737 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	738 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	739 .^ 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	740 values of @var{x} or @var{y}.\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	741 @end deftypefn")
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	742 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	743 octave_value retval;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	744
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	745 int nargin = args.length ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	746
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	747 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	748 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	749 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	750 error ("hypot: not defined for integer types");
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	751 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	752 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	753 octave_value arg_x = args(0);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	754 octave_value arg_y = args(1);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	755
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	756 dim_vector x_dims = arg_x.dims ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	757 dim_vector y_dims = arg_y.dims ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	758
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	759 bool x_is_scalar = x_dims.all_ones ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	760 bool y_is_scalar = y_dims.all_ones ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	761
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	762 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	763
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	764 if (y_is_scalar && x_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	765 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	766 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	767 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	768 float x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	769 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	770 x = abs (arg_x.float_complex_value ());
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	771 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	772 x = arg_x.float_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	773
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	774 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	775 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	776 float y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	777 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	778 y = abs (arg_y.float_complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	779 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	780 y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	781
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	782 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	783 retval = hypotf (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	784 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	787 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	788 double x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	789 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	790 x = abs (arg_x.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	791 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	792 x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	793
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	794 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	795 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	796 double y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	797 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	798 y = abs (arg_y.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	799 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	800 y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	801
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	802 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	803 retval = hypot (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	804 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	805 }
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 else if (y_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	808 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	809 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	810 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	811 FloatNDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	812 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	813 x = arg_x.float_complex_array_value ().abs ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	814 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	815 x = arg_x.float_array_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	816
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	817 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	818 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	819 float y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	820 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	821 y = abs (arg_y.float_complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	822 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	823 y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	824
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	825 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	826 retval = map_fm_f (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	827 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	830 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	831 NDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	832 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	833 x = arg_x.complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	834 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	835 x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	836
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	837 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	838 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	839 double y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	840 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	841 y = abs (arg_y.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	842 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	843 y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	844
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	845 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	846 retval = map_m_d (hypot, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	847 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	848 }
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 else if (x_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	851 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	852 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	853 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	854 float x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	855 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	856 x = abs (arg_x.float_complex_value ());
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	857 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	858 x = arg_x.float_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	859
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	860 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	861 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	862 FloatNDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	863 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	864 y = arg_y.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	865 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	866 y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	867
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	868 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	869 retval = map_f_fm (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	870 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	873 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	874 double x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	875 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	876 x = abs (arg_x.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	877 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	878 x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	879
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	880 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	881 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	882 NDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	883 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	884 y = arg_y.complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	885 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	886 y = arg_y.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	887
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	888 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	889 retval = map_d_m (hypot, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	890 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	891 }
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 else if (y_dims == x_dims)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	894 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	895 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	896 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	897 SparseMatrix x;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	898 if (arg_x.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	899 x = arg_x.sparse_complex_matrix_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	900 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	901 x = arg_x.sparse_matrix_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	902
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	903 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	904 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	905 SparseMatrix y;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	906 if (arg_y.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	907 y = arg_y.sparse_complex_matrix_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	908 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	909 y = arg_y.sparse_matrix_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	910
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	911 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	912 retval = map_s_s (hypot, x, y);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	913 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	914 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	915 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	916 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	917 FloatNDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	918 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	919 x = arg_x.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	920 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	921 x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	922
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	923 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	924 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	925 FloatNDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	926 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	927 y = arg_y.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	928 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	929 y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	930
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	931 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	932 retval = map_fm_fm (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	933 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	934 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	935 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	936 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	937 NDArray x;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	938 if (arg_x.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	939 x = arg_x.complex_array_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	940 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	941 x = arg_x.array_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	942
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	943 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	944 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	945 NDArray y;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	946 if (arg_y.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	947 y = arg_y.complex_array_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	948 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	949 y = arg_y.array_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	950
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	951 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	952 retval = map_m_m (hypot, x, y);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	953 }
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 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	957 error ("hypot: nonconformant matrices");
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	958 }
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 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	961 print_usage ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	962
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	963 return retval;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	964 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	965
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	966 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	967 %!assert (size (hypot (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	968 %!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	969 %!assert (size (hypot (rand (2, 3, 4), 1)), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	970 %!assert (size (hypot (1, rand (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	971 %!assert (size (hypot (1, 2)), [1, 1])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	972 %!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	973 %!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	974 */
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	975
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	976 template<typename T, typename ET>
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	977 void
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	978 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	979 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	980 f = Array<T>(x.dims ());
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	981 e = Array<ET>(x.dims ());
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	982 for (octave_idx_type i = 0; i < x.numel (); i++)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	983 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	984 int exp;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	985 f.xelem (i) = xlog2 (x(i), exp);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	986 e.xelem (i) = exp;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	987 }
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 DEFUN (log2, args, nargout,
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	991 "-- texinfo --\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	992 @deftypefn {Mapping Function} {} log2 (@var{x})\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	993 @deftypefnx {Mapping Function} {[@var{f}, @var{e}] = } log2 (@var{x})\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	994 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	995 If called with two output arguments, split @var{x} to\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	996 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	997 @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	998 @seealso{log, log10, log2, exp}\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	999 @end deftypefn")
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1000 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1001 octave_value_list retval;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1002
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1003 if (args.length () == 1)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1004 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1005 if (nargout < 2)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1006 retval(0) = args(0).log2 ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1007 else if (args(0).is_single_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1008 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1009 if (args(0).is_real_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1010 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1011 FloatNDArray f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1012 FloatNDArray x = args(0).float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1013 // FIXME -- should E be an int value?
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1014 FloatMatrix e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1015 map_2_xlog2 (x, f, e);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1016 retval (1) = e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1017 retval (0) = f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1018 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1019 else if (args(0).is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1020 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1021 FloatComplexNDArray f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1022 FloatComplexNDArray x = args(0).float_complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1023 // FIXME -- should E be an int value?
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1024 FloatNDArray e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1025 map_2_xlog2 (x, f, e);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1026 retval (1) = e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1027 retval (0) = f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1028 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1029 }
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1030 else if (args(0).is_real_type ())
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1031 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1032 NDArray f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1033 NDArray x = args(0).array_value ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1034 // FIXME -- should E be an int value?
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1035 Matrix e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1036 map_2_xlog2 (x, f, e);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1037 retval (1) = e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1038 retval (0) = f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1039 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1040 else if (args(0).is_complex_type ())
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1041 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1042 ComplexNDArray f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1043 ComplexNDArray x = args(0).complex_array_value ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1044 // FIXME -- should E be an int value?
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1045 NDArray e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1046 map_2_xlog2 (x, f, e);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1047 retval (1) = e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1048 retval (0) = f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1049 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1050 else
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1051 gripe_wrong_type_arg ("log2", args(0));
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1052 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1053 else
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1054 print_usage ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1055
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1056 return retval;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1057 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1058
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1059 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1060 %!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	1061 %!assert(log2(Inf), Inf);
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1062 %!assert(isnan(log2(NaN)));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1063 %!assert(log2(4i), 2 + log2(1i));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1064 %!assert(log2(complex(0,Inf)), Inf + log2(i));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1065
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1066 %!test
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1067 %! [f, e] = log2 ([0,-1; 2,-4; Inf,-Inf]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1068 %! assert (f, [0,-0.5; 0.5,-0.5; Inf,-Inf]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1069 %! assert (e, [0,1;2,3;0,0])
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1070
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1071 %!test
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1072 %! [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	1073 %! 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	1074 %! assert (e, [0,1; 2,3; 0,0]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1075 */
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1076
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1077 DEFUN (fmod, args, ,
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1078 "-- texinfo --\n\
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1079 @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	1080 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	1081 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	1082 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	1083 @end deftypefn")
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1084 {
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1085 octave_value retval;
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1086
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1087 int nargin = args.length ();
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1088
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1089 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	1090 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1091 octave_value arg_y = args(0);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1092 octave_value arg_x = args(1);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1093
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1094 dim_vector y_dims = arg_y.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1095 dim_vector x_dims = arg_x.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1096
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1097 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	1098 bool x_is_scalar = x_dims.all_ones ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1099
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1100 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	1101
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1102 if (y_is_scalar && x_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1103 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1104 if (is_float)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1105 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1106 float y = arg_y.float_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1107
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1108 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1109 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1110 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1111
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1112 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1113 retval = fmod (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1114 }
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 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1117 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1118 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1119
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1120 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1121 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1122 double x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1123
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1124 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1125 retval = fmod (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1126 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1127 }
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 else if (y_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1130 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1131 if (is_float)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1132 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1133 float y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1134
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1135 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	1136 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1137 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	1138
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1139 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1140 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	1141 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1142 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1143 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1144 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1145 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1146
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1147 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	1148 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1149 if (arg_x.is_sparse_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1150 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1151 SparseMatrix x = arg_x.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1152
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1153 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1154 retval = map_s_d (fmod, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1155 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1156 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1157 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1158 NDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1159
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1160 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1161 retval = map_m_d (fmod, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1162 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1163 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1164 }
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 else if (x_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1167 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1168 if (arg_y.is_sparse_type ())
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1169 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1170 SparseMatrix y = arg_y.sparse_matrix_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1171
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1172 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	1173 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1174 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	1175
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1176 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	1177 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	1178 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1179 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1180 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1181 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1182 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1183
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1184 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1185 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1186 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1187
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1188 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1189 retval = map_f_fm (fmodf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1190 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1191 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1192 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1193 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1194 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	1195
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1196 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	1197 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1198 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	1199
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1200 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	1201 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	1202 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1203 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1204 }
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1205 else if (y_dims == x_dims)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1206 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1207 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	1208 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1209 SparseMatrix y = arg_y.sparse_matrix_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1210
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1211 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	1212 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1213 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	1214
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1215 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	1216 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	1217 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1218 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1219 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1220 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1221 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1222
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1223 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1224 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1225 FloatNDArray x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1226
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1227 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1228 retval = map_fm_fm (fmodf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1229 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1230 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1231 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1232 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1233 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	1234
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1235 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	1236 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1237 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	1238
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1239 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	1240 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	1241 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1242 }
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 else
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1245 error ("fmod: nonconformant matrices");
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1246 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1247 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1248 print_usage ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1249
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1250 return retval;
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1251 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1252
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1253 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1254 %!assert (size (fmod (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1255 %!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	1256 %!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	1257 %!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	1258 %!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	1259 */
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1260
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1261 // 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	1262
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1263 #define NATIVE_REDUCTION_1(FCN, TYPE, DIM) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1264 (arg.is_ ## TYPE ## _type ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1265 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1266 TYPE ## NDArray tmp = arg. TYPE ##_array_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1267 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1268 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1269 retval = tmp.FCN (DIM); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1270 }
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 #define NATIVE_REDUCTION(FCN) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1273 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1274 octave_value retval; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1275 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1276 int nargin = args.length (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1277 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1278 bool isnative = false; \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1279 bool isdouble = false; \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1280 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1281 if (nargin > 1 && args(nargin - 1).is_string ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1282 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1283 std::string str = args(nargin - 1).string_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1284 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1285 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1286 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1287 if (str == "native") \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1288 isnative = true; \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1289 else if (str == "double") \
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1290 isdouble = true; \
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1291 else \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1292 error ("sum: unrecognized string argument"); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1293 nargin --; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1294 } \
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 if (nargin == 1 \|\| nargin == 2) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1298 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1299 octave_value arg = args(0); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1300 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1301 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	1302 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1303 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1304 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1305 if (dim >= -1) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1306 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1307 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1308 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1309 if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1310 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1311 SparseMatrix tmp = arg.sparse_matrix_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1312 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1313 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1314 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1315 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1316 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1317 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1318 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	1319 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1320 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1321 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1322 } \
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 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1325 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1326 if (isnative) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1327 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1328 if NATIVE_REDUCTION_1 (FCN, uint8, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1329 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	1330 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	1331 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	1332 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	1333 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	1334 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	1335 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	1336 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	1337 else if (arg.is_char_matrix ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1338 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1339 error (#FCN, ": invalid char type"); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1340 } \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1341 else if (!isdouble && arg.is_single_type ()) \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1342 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1343 if (arg.is_complex_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1344 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1345 FloatComplexNDArray tmp = \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1346 arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1347 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1348 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1349 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1350 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1351 else if (arg.is_real_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1352 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1353 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1354 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1355 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1356 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1357 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1358 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1359 else if (arg.is_complex_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1360 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1361 ComplexNDArray tmp = arg.complex_array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1362 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1363 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1364 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1365 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1366 else if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1367 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1368 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1369 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1370 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1371 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1372 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1373 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1374 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1375 gripe_wrong_type_arg (#FCN, arg); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1376 return retval; \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1377 } \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1378 } \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1379 else if (!isdouble && arg.is_single_type ()) \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1380 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1381 if (arg.is_real_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1382 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1383 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1384 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1385 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1386 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1387 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1388 else if (arg.is_complex_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1389 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1390 FloatComplexNDArray tmp = \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1391 arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1392 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1393 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1394 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1395 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1396 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1397 else if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1398 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1399 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1400 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1401 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1402 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1403 } \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1404 else if (arg.is_complex_type ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1405 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1406 ComplexNDArray tmp = arg.complex_array_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1407 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1408 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1409 retval = tmp.FCN (dim); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1410 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1411 else \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1412 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1413 gripe_wrong_type_arg (#FCN, arg); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1414 return retval; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1415 } \
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 else \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1419 error (#FCN ": invalid dimension argument = %d", dim + 1); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1420 } \
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 else \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1424 print_usage (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1425 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1426 return retval
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1427
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1428 #define DATA_REDUCTION(FCN) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1429 \
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	1430 octave_value retval; \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1431 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1432 int nargin = args.length (); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1433 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1434 if (nargin == 1 \|\| nargin == 2) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1435 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1436 octave_value arg = args(0); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1437 \
3864 e78705239df5 [project @ 2001-11-16 12:56:20 by jwe] jwe parents: 3797 diff changeset	1438 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	1439 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1440 if (! error_state) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1441 { \
4556 773a21e4fce8 [project @ 2003-10-28 05:02:10 by jwe] jwe parents: 4554 diff changeset	1442 if (dim >= -1) \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1443 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1444 if (arg.is_real_type ()) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1445 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1446 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1447 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1448 SparseMatrix tmp = arg.sparse_matrix_value (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1449 \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1450 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1451 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1452 } \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1453 else if (arg.is_single_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1454 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1455 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1456 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1457 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1458 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1459 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1460 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1461 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1462 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1463 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1464 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1465 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1466 } \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1467 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1468 else if (arg.is_complex_type ()) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1469 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1470 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1471 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1472 SparseComplexMatrix tmp = arg.sparse_complex_matrix_value (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1473 \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1474 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1475 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1476 } \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1477 else if (arg.is_single_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1478 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1479 FloatComplexNDArray tmp = arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1480 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1481 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1482 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1483 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1484 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1485 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1486 ComplexNDArray tmp = arg.complex_array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1487 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1488 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1489 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1490 } \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1491 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1492 else \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1493 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1494 gripe_wrong_type_arg (#FCN, arg); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1495 return retval; \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1496 } \
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 else \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1499 error (#FCN ": invalid dimension argument = %d", dim + 1); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1500 } \
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 else \
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1503 print_usage (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1504 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1505 return retval
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1506
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1507 DEFUN (cumprod, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1508 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1509 @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	1510 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	1511 @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	1512 products).\n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1513 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1514 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	1515 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	1516 same orientation as @var{x}.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1517 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1518 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1519 DATA_REDUCTION (cumprod);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1520 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1521
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1522 /*
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 %!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	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 ([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	1527 %!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	1528
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1529 %!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	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([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	1532 %!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	1533
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1534 %!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	1535
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1536 %!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	1537 %!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	1538
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1539 %!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	1540 %!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	1541
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
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1544 DEFUN (cumsum, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1545 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1546 @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	1547 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	1548 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	1549 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1550 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	1551 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	1552 same orientation as @var{x}.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1553 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1554 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1555 DATA_REDUCTION (cumsum);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1556 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1557
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1558 /*
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 %!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	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 ([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	1563 %!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	1564
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1565 %!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	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([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	1568 %!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	1569
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1570 %!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	1571
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1572 %!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	1573 %!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	1574
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1575 %!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	1576 %!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	1577
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
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1580 DEFUN (diag, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1581 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1582 @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	1583 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	1584 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	1585 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	1586 @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	1587 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	1588 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1589 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1590 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1591 diag ([1, 2, 3], 1)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1592 @result{} 0 1 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1593 0 0 2 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1594 0 0 0 3\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1595 0 0 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1596 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1597 @end example\n\
6772 315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1598 \n\
315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1599 @noindent\n\
315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1600 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	1601 @var{k}-th diagonal of the matrix.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1602 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1603 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	1604 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1605
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1606 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1607
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	1608 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	1609 retval = args(0).diag();
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	1610 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	1611 {
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1612 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	1613
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1614 if (error_state)
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1615 error ("diag: invalid second argument");
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1616 else
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1617 retval = args(0).diag(k);
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1618 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1619 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1620 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1621
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1622 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1623 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1624
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1625 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1626
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1627 %!assert(diag ([1; 2; 3]), [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	1628 %!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	1629 %!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	1630 %!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	1631 %!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	1632
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1633 %!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	1634 %!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	1635 %!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	1636
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1637 %!assert(diag (single([1; 2; 3])), single([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	1638 %!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	1639 %!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	1640 %!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	1641 %!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	1642
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 (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	1644 %!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	1645 %!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	1646
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1647 %!assert(diag (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	1648 %!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	1649 %!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	1650 %!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	1651 %!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	1652
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 (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	1654 %!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	1655 %!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	1656
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1657 %!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	1658 %!error <Invalid call to diag.*> diag (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
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1660 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1661
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1662 DEFUN (prod, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1663 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1664 @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	1665 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	1666 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	1667 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1668 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	1669 return the product of the elements.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1670 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1671 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1672 DATA_REDUCTION (prod);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1673 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1674
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1675 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1676
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1677 %!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	1678 %!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	1679 %!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	1680 %!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	1681
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1682 %!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	1683 %!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	1684 %!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	1685 %!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	1686
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1687 %!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	1688
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1689 %!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	1690 %!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	1691 %!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	1692 %!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	1693 %!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	1694 %!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	1695 %!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	1696 %!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	1697 %!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	1698 %!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	1699 %!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	1700 %!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	1701 %!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	1702 %!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	1703
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1704 %!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	1705 %!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	1706 %!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	1707 %!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	1708 %!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	1709 %!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	1710 %!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	1711 %!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	1712 %!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	1713 %!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	1714 %!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	1715 %!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	1716 %!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	1717 %!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	1718
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1719 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1720
8107 8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1721 #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	1722 do \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1723 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1724 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	1725 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	1726 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1727 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	1728 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1729 OCTAVE_QUIT; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1730 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1731 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	1732 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1733 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	1734 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1735 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	1736 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1737 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	1738 return retval; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1739 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1740 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	1741 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1742 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	1743 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1744 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	1745 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	1746 break; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1747 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1748 else \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1749 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	1750 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1751 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1752 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1753 while (0)
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1754
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1755 #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	1756 do \
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 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	1759 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1760 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	1761 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1762 retval = result; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1763 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1764 while (0)
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1765
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1766 static octave_value
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1767 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	1768 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1769 octave_value retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1770
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1771 int n_args = args.length ();
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1772
5714 24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1773 if (n_args == 1)
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1774 retval = Matrix ();
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1775 else if (n_args == 2)
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1776 retval = args(1);
5507 273612001e3a [project @ 2005-10-26 08:01:24 by dbateman] dbateman parents: 5476 diff changeset	1777 else if (n_args > 2)
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1778 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1779 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	1780
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1781 if (error_state)
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1782 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1783 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	1784 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1785 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1786
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1787 if (dim >= 0)
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1788 {
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1789
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1790 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	1791 std::string result_type = args(1).class_name ();
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1792
8107 8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1793 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	1794 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	1795 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	1796 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	1797
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1798 for (int i = 2; i < args.length (); i++)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1799 {
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1800 // 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	1801 // dimensions of the final array after concatenation.
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1802
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1803 if (! dv.concat (args(i).dims (), dim))
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1804 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1805 // Dimensions do not match.
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1806 error ("cat: dimension mismatch");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1807 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1808 }
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1809
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1810 result_type =
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1811 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	1812
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1813 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	1814 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	1815 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	1816 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	1817 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	1818 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	1819 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	1820 any_sparse_p = true;
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1821 }
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 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 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	1824 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1825 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	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_real_p)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1828 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	1829 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1830 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	1831 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1832 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1833 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1834 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	1835 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	1836 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1837 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	1838 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1839 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1840 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	1841 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1842 if (all_real_p)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1843 DO_SINGLE_TYPE_CONCAT (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	1844 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1845 DO_SINGLE_TYPE_CONCAT (FloatComplexNDArray,
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1846 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	1847 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1848 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	1849 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1850 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	1851
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1852 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	1853
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1854 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	1855
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1856 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	1857
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1858 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	1859 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1860 else if (result_type == "logical")
5533 667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1861 {
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1862 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	1863 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	1864 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1865 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	1866 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1867 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	1868 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	1869 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	1870 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	1871 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	1872 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	1873 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	1874 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	1875 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	1876 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	1877 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	1878 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	1879 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	1880 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	1881 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	1882 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	1883 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1884 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1885 // 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	1886 // 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	1887 // 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	1888 // 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	1889 // 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	1890 // 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	1891 // 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	1892 //
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1893 // 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	1894 // 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	1895 // (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	1896 // 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	1897 // 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	1898
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1899 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	1900 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	1901
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1902 if (error_state)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1903 return retval;
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1904
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1905 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	1906 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	1907
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1908 for (int j = 1; j < n_args; j++)
6401 f8cbc0871ed6 [project @ 2007-03-09 15:34:45 by dbateman] dbateman parents: 6399 diff changeset	1909 {
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1910 // 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	1911 // 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	1912 // 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	1913 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	1914
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1915 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	1916 return retval;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1917
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1918 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	1919
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1920 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	1921 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1922 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	1923 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	1924 break;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1925 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1926 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1927 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	1928 dv_tmp (dim) : 1);
6401 f8cbc0871ed6 [project @ 2007-03-09 15:34:45 by dbateman] dbateman parents: 6399 diff changeset	1929 }
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1930 retval = tmp;
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1931 }
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1932
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1933 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	1934 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1935 // 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	1936 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	1937 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	1938 }
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1939 }
5533 667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1940 else
667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1941 error ("%s: invalid dimension argument", fname.c_str ());
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1942 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1943 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1944 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	1945
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1946 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1947 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1948
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1949 DEFUN (horzcat, args, ,
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1950 "-- texinfo --\n\
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1951 @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	1952 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	1953 @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	1954 @seealso{cat, vertcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	1955 @end deftypefn")
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 octave_value_list args_tmp = args;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1958
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1959 int dim = 2;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1960
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1961 octave_value d (dim);
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 args_tmp.prepend (d);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1964
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1965 return do_cat (args_tmp, "horzcat");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1966 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1967
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1968 DEFUN (vertcat, args, ,
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1969 "-- texinfo --\n\
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1970 @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	1971 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	1972 @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	1973 @seealso{cat, horzcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	1974 @end deftypefn")
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1975 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1976 octave_value_list args_tmp = args;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1977
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1978 int dim = 1;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1979
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1980 octave_value d (dim);
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 args_tmp.prepend (d);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1983
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1984 return do_cat (args_tmp, "vertcat");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1985 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1986
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1987 DEFUN (cat, args, ,
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1988 "-- texinfo --\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1989 @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	1990 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	1991 @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	1992 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1993 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1994 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1995 A = ones (2, 2);\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1996 B = zeros (2, 2);\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1997 cat (2, A, B)\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1998 @result{} ans =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1999 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2000 1 1 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2001 1 1 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2002 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2003 @end example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2004 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2005 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	2006 second dimension the following way:\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2007 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2008 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2009 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2010 [A, B].\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2011 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2012 @end example\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 @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	2015 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	2016 following example shows:\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2017 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2018 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2019 cat (4, ones(2, 2), zeros (2, 2))\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2020 @result{} ans =\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 ans(:,:,1,1) =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2023 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2024 1 1\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2025 1 1\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2026 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2027 ans(:,:,1,2) =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2028 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2029 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2030 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2031 @end example\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2032 @seealso{horzcat, vertcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2033 @end deftypefn")
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2034 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	2035 return do_cat (args, "cat");
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2036 }
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2037
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2038 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2039
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2040 %!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	2041 %! 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	2042 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2043 %! 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	2044 %! 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	2045 %! 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	2046 %! 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	2047 %! 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	2048 %! 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	2049 %! 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	2050 %! 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	2051 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2052 %! 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	2053 %! 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	2054 %! 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	2055 %! 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	2056 %! 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	2057 %! 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	2058 %! 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	2059 %! 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	2060 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2061 %! 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	2062 %! 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	2063 %! 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	2064 %! 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	2065 %! 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	2066 %! 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	2067 %! 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	2068 %! 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	2069 %! 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	2070 %!
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(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	2072 %! 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	2073 %! 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	2074 %! 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	2075 %! 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	2076 %! 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	2077 %! 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	2078 %! 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	2079 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2080 %! assert (cat (1, cast (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	2081 %! 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	2082 %! 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	2083 %! 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	2084 %! 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	2085 %! 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	2086 %! 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	2087 %! 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	2088 %!
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(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	2090 %! 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	2091 %! 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	2092 %! 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	2093 %! 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	2094 %! 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	2095 %! 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	2096 %! 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	2097 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2098 %! assert (cat (1, cast (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	2099 %! 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	2100 %! 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	2101 %! 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	2102 %! 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	2103 %! 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	2104 %! 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	2105 %! 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	2106 %!
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(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	2108 %! 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	2109 %! 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	2110 %! 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	2111 %! 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	2112 %! 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	2113 %! 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	2114 %! 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	2115 %! endif
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2116 %! ret = true;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2117
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2118 %!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	2119 %!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	2120 %!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	2121 %!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	2122
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2123 %!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	2124 %!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	2125 %!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	2126 %!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	2127 %!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	2128 %!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	2129 %!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	2130 %!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	2131 %!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	2132 %!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	2133 %!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	2134 %!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	2135 %!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	2136 %!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	2137 %!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	2138 %!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	2139 %!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	2140 %!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	2141 %!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	2142 %!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	2143
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('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	2145 %!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	2146 %!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	2147 %!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	2148 %!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	2149 %!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	2150 %!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	2151 %!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	2152 %!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	2153 %!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	2154 %!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	2155 %!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	2156 %!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	2157 %!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	2158 %!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	2159 %!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	2160 %!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	2161 %!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	2162 %!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	2163 %!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	2164
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2165 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2166
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2167 static octave_value
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2168 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	2169 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2170 octave_value retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2171
5148 9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2172 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	2173 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2174 Array<int> vec = args(1).int_vector_value ();
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2175
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	2176 // 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	2177 // here and pass that to permute?
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2178
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2179 int n = vec.length ();
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2180
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2181 for (int i = 0; i < n; i++)
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2182 vec(i)--;
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2183
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2184 octave_value ret = args(0).permute (vec, inv);
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2185
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2186 if (! error_state)
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2187 retval = ret;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2188 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2189 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2190 print_usage ();
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2191
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2192 return retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2193 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2194
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2195 DEFUN (permute, args, ,
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2196 "-- texinfo --\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2197 @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	2198 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	2199 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	2200 @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	2201 @seealso{ipermute}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2202 @end deftypefn")
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2203 {
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2204 return do_permute (args, false);
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
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2207 DEFUN (ipermute, args, ,
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2208 "-- texinfo --\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2209 @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	2210 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	2211 \n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2212 @example\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2213 ipermute (permute (a, perm), perm)\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2214 @end example\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2215 returns the original array @var{a}.\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2216 @seealso{permute}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2217 @end deftypefn")
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2218 {
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2219 return do_permute (args, true);
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2220 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2221
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2222 DEFUN (length, args, ,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2223 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2224 @deftypefn {Built-in Function} {} length (@var{a})\n\
4176 b8ec44432831 [project @ 2002-11-13 02:49:14 by jwe] jwe parents: 4153 diff changeset	2225 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	2226 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	2227 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	2228 @end deftypefn")
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2229 {
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2230 octave_value retval;
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2231
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2232 if (args.length () == 1)
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2233 {
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2234 int len = args(0).length ();
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2235
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2236 if (! error_state)
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	2237 retval = len;
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2238 }
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2239 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2240 print_usage ();
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2241
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2242 return retval;
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
4554 78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2245 DEFUN (ndims, args, ,
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2246 "-- texinfo --\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2247 @deftypefn {Built-in Function} {} ndims (@var{a})\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2248 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	2249 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	2250 Trailing singleton dimensions are not counted.\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2251 @end deftypefn")
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2252 {
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2253 octave_value retval;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2254
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2255 if (args.length () == 1)
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2256 {
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2257 int n_dims = args(0).ndims ();
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2258
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2259 if (! error_state)
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2260 retval = n_dims;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2261 }
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2262 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2263 print_usage ();
4554 78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2264
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2265 return retval;
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
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2268 DEFUN (numel, args, ,
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2269 "-- texinfo --\n\
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2270 @deftypefn {Built-in Function} {} numel (@var{a})\n\
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2271 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	2272 @seealso{size}\n\
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2273 @end deftypefn")
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2274 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2275 octave_value retval;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2276
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2277 if (args.length () == 1)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2278 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2279 int numel = args(0).numel ();
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2280
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2281 if (! error_state)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2282 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2283 if (numel < 0)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2284 numel = 0;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2285
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2286 retval = numel;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2287 }
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 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2290 print_usage ();
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2291
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2292 return retval;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2293 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2294
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2295 DEFUN (size, args, nargout,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2296 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2297 @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	2298 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	2299 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2300 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	2301 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	2302 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	2303 etc. For example,\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2304 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2305 @example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2306 @group\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2307 size ([1, 2; 3, 4; 5, 6])\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2308 @result{} [ 3, 2 ]\n\
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2309 \n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2310 [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	2311 @result{} nr = 3\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2312 @result{} nc = 2\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2313 @end group\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2314 @end example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2315 \n\
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2316 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	2317 corresponding dimension. For example\n\
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2318 \n\
3373 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 size ([1, 2; 3, 4; 5, 6], 2)\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2321 @result{} 2\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2322 @end example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2323 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2324 @noindent\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2325 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	2326 @seealso{numel}\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2327 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2328 {
2086 bfb775fb6fe8 [project @ 1996-04-25 05:55:19 by jwe] jwe parents: 1996 diff changeset	2329 octave_value_list retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2330
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2331 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2332
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2333 if (nargin == 1)
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2334 {
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2335 dim_vector dimensions = args(0).dims ();
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2336
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2337 int ndims = dimensions.length ();
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2338
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2339 Matrix m (1, ndims);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2340
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2341 if (nargout > 1)
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2342 {
5991 265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2343 for (int i = nargout-1; i >= ndims; i--)
265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2344 retval(i) = 1;
265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2345
6197 c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2346 if (ndims > nargout)
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2347 {
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2348 octave_idx_type d = 1;
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2349
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2350 while (ndims >= nargout)
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2351 d *= dimensions(--ndims);
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2352
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2353 retval(ndims) = d;
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2354 }
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2355
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2356 while (ndims--)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2357 retval(ndims) = dimensions(ndims);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2358 }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2359 else
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2360 {
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2361 for (int i = 0; i < ndims; i++)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2362 m(0, i) = dimensions(i);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2363
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2364 retval(0) = m;
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2365 }
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2366 }
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2367 else if (nargin == 2 && nargout < 2)
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2368 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	2369 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	2370
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2371 if (error_state)
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2372 error ("size: expecting scalar as second argument");
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2373 else
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2374 {
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2375 dim_vector dv = args(0).dims ();
e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2376
4911 14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2377 if (nd > 0)
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2378 {
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2379 if (nd <= dv.length ())
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2380 retval(0) = dv(nd-1);
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2381 else
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2382 retval(0) = 1;
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2383 }
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2384 else
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2385 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	2386 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2387 }
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2388 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2389 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2390
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2391 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2392 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2393
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2394 DEFUN (size_equal, args, ,
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2395 "-- texinfo --\n\
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2396 @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	2397 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	2398 Trailing singleton dimensions are ignored.\n\
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2399 @seealso{size, numel}\n\
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2400 @end deftypefn")
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2401 {
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2402 octave_value retval;
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2403
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2404 int nargin = args.length ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2405
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2406 if (nargin >= 2)
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2407 {
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2408 retval = true;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2409
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2410 dim_vector a_dims = args(0).dims ();
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2411 a_dims.chop_trailing_singletons ();
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2412
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2413 for (int i = 1; i < nargin; ++i)
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2414 {
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2415 dim_vector b_dims = args(i).dims ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2416 b_dims.chop_trailing_singletons ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2417
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2418 if (a_dims != b_dims)
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 retval = false;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2421 break;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2422 }
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 }
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2425 else
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2426 print_usage ();
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2427
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2428 return retval;
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2429 }
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2430
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2431 DEFUN (nnz, args, ,
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2432 "-- texinfo --\n\
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2433 @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	2434 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	2435 @seealso{sparse}\n\
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2436 @end deftypefn")
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2437 {
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2438 octave_value retval;
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2439
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2440 if (args.length () == 1)
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2441 retval = args(0).nnz ();
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2442 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2443 print_usage ();
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2444
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2445 return retval;
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2446 }
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2447
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2448 DEFUN (nzmax, args, ,
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2449 "-- texinfo --\n\
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2450 @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	2451 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	2452 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	2453 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	2454 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	2455 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	2456 @seealso{sparse, spalloc}\n\
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2457 @end deftypefn")
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2458 {
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2459 octave_value retval;
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2460
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2461 if (args.length() == 1)
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2462 retval = args(0).nzmax ();
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2463 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2464 print_usage ();
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2465
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2466 return retval;
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2467 }
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2468
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2469 DEFUN (rows, args, ,
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2470 "-- texinfo --\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2471 @deftypefn {Built-in Function} {} rows (@var{a})\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2472 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	2473 @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	2474 @end deftypefn")
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2475 {
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2476 octave_value retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2477
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2478 if (args.length () == 1)
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2479 retval = args(0).rows ();
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2480 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2481 print_usage ();
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2482
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2483 return retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2484 }
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2485
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2486 DEFUN (columns, args, ,
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2487 "-- texinfo --\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2488 @deftypefn {Built-in Function} {} columns (@var{a})\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2489 Return the number of columns of @var{a}.\n\
5724 82247c2a7520 [project @ 2006-03-30 21:34:52 by jwe] jwe parents: 5714 diff changeset	2490 @seealso{size, numel, rows, length, isscalar, isvector, and ismatrix}\n\
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2491 @end deftypefn")
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2492 {
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2493 octave_value retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2494
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2495 if (args.length () == 1)
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2496 retval = args(0).columns ();
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2497 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2498 print_usage ();
5677 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 return retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2501 }
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2502
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2503 DEFUN (sum, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2504 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2505 @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	2506 @deftypefnx {Built-in Function} {} sum (@dots{}, 'native')\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2507 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	2508 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	2509 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2510 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	2511 return the sum of the elements.\n\
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2512 \n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2513 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	2514 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	2515 double type. For example\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2516 \n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2517 @example\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2518 sum ([true, true])\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2519 @result{} 2\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2520 sum ([true, true], 'native')\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2521 @result{} true\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2522 @end example\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2523 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2524 {
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2525 NATIVE_REDUCTION (sum);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2526 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2527
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2528 /*
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2529
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2530 %!assert (sum([true,true]), 2)
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2531 %!assert (sum([true,true],'native'), true)
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2532 %!assert (sum(int8([127,10,-20])), 117);
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2533 %!assert (sum(int8([127,10,-20]),'native'), int8(107));
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2534
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2535 %!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	2536 %!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	2537 %!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	2538 %!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	2539
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2540 %!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	2541 %!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	2542 %!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	2543 %!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	2544
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2545 %!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	2546
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2547 %!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	2548 %!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	2549 %!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	2550 %!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	2551 %!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	2552 %!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	2553 %!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	2554 %!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	2555 %!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	2556 %!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	2557 %!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	2558 %!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	2559 %!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	2560 %!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	2561 %!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	2562 %!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	2563 %!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	2564 %!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	2565 %!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	2566
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2567 %!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	2568 %!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	2569 %!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	2570 %!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	2571 %!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	2572 %!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	2573 %!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	2574 %!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	2575 %!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	2576 %!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	2577 %!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	2578 %!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	2579 %!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	2580 %!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	2581 %!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	2582 %!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	2583 %!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	2584 %!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	2585 %!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	2586
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2587 */
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2588
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2589 DEFUN (sumsq, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2590 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2591 @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	2592 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	2593 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	2594 \n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2595 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	2596 return the sum of squares of the elements.\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2597 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2598 This function is conceptually equivalent to computing\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2599 @example\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2600 sum (x .* conj (x), dim)\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2601 @end example\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2602 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	2603 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2604 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2605 DATA_REDUCTION (sumsq);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2606 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2607
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2608 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2609
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2610 %!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	2611 %!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	2612 %!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	2613
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2614 %!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	2615 %!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	2616 %!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	2617
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2618 %!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	2619
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2620 %!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	2621 %!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	2622
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2623 %!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	2624 %!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	2625
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2626 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2627
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2628 DEFUN (islogical, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2629 "-- texinfo --\n\
7144 30c0533e39ae [project @ 2007-11-09 17:37:24 by jwe] jwe parents: 7112 diff changeset	2630 @deftypefn {Built-in Function} {} islogical (@var{x})\n\
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2631 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	2632 @end deftypefn")
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2633 {
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2634 octave_value retval;
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2635
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2636 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2637 retval = args(0).is_bool_type ();
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2638 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2639 print_usage ();
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2640
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2641 return retval;
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2642 }
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2643
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2644 DEFALIAS (isbool, islogical);
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2645
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2646 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2647
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2648 %!assert (islogical(true), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2649 %!assert (islogical(false), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2650 %!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	2651 %!assert (islogical(1), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2652 %!assert (islogical(1i), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2653 %!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	2654 %!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	2655 %!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	2656 %!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	2657
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2658 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2659
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2660 DEFUN (isinteger, args, ,
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2661 "-- texinfo --\n\
6230 06bee64edc08 [project @ 2007-01-08 16:59:35 by jwe] jwe parents: 6223 diff changeset	2662 @deftypefn {Built-in Function} {} isinteger (@var{x})\n\
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2663 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	2664 Note that @code{isinteger (14)} is false because numeric constants in\n\
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2665 are double precision floating point values.\n\
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2666 @seealso{isreal, isnumeric, class, isa}\n\
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2667 @end deftypefn")
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2668 {
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2669 octave_value retval;
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2670
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2671 if (args.length () == 1)
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2672 retval = args(0).is_integer_type ();
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2673 else
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2674 print_usage ();
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2675
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2676 return retval;
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2677 }
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2678
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	2679 DEFUN (iscomplex, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2680 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	2681 @deftypefn {Built-in Function} {} iscomplex (@var{x})\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2682 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	2683 @end deftypefn")
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2684 {
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2685 octave_value retval;
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2686
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2687 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2688 retval = args(0).is_complex_type ();
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2689 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2690 print_usage ();
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2691
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2692 return retval;
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2693 }
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2694
7576 7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2695 DEFUN (isfloat, args, ,
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2696 "-- texinfo --\n\
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2697 @deftypefn {Built-in Function} {} isfloat (@var{x})\n\
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2698 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	2699 @end deftypefn")
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2700 {
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2701 octave_value retval;
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2702
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2703 if (args.length () == 1)
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2704 retval = args(0).is_float_type ();
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2705 else
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2706 print_usage ();
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2707
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2708 return retval;
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2709 }
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2710
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	2711 // FIXME -- perhaps this should be implemented with an
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2712 // octave_value member function?
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2713
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2714 DEFUN (complex, args, ,
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2715 "-- texinfo --\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2716 @deftypefn {Built-in Function} {} complex (@var{val})\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2717 @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	2718 Convert @var{x} to a complex value.\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2719 @end deftypefn")
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2720 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2721 octave_value retval;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2722
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2723 int nargin = args.length ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2724
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2725 if (nargin == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2726 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2727 octave_value arg = args(0);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2728
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2729 if (arg.is_complex_type ())
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2730 retval = arg;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2731 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2732 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2733 if (arg.is_sparse_type ())
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2734 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2735 SparseComplexMatrix val = arg.sparse_complex_matrix_value ();
5476 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 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2738 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	2739 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2740 else if (arg.is_single_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2741 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2742 if (arg.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2743 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2744 FloatComplex val = arg.float_complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2745
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2746 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2747 retval = octave_value (new octave_float_complex (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2748 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2749 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2750 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2751 FloatComplexNDArray val = arg.float_complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2752
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2753 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2754 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	2755 }
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2756 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2757 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2758 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2759 if (arg.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2760 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2761 Complex val = arg.complex_value ();
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 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2764 retval = octave_value (new octave_complex (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2765 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2766 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2767 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2768 ComplexNDArray val = arg.complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2769
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2770 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2771 retval = octave_value (new octave_complex_matrix (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2772 }
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2773 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2774
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2775 if (error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2776 error ("complex: invalid conversion");
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2777 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2778 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2779 else if (nargin == 2)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2780 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2781 octave_value re = args(0);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2782 octave_value im = args(1);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2783
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2784 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	2785 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2786 const SparseMatrix re_val = re.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2787 const SparseMatrix im_val = im.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2788
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2789 if (!error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2790 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2791 if (re.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2792 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2793 SparseComplexMatrix result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2794 if (re_val.nnz () == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2795 result = Complex(0, 1) * SparseComplexMatrix (im_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2796 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2797 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2798 result = SparseComplexMatrix (im_val.dims (), re_val (0));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2799 octave_idx_type nr = im_val.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2800 octave_idx_type nc = im_val.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2801
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2802 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	2803 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2804 octave_idx_type off = j * nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2805 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	2806 i < im_val.cidx(j + 1); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2807 result.data (im_val.ridx(i) + off) =
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2808 result.data (im_val.ridx(i) + off) +
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2809 Complex (0, im_val.data (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2810 }
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 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	2813 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2814 else if (im.numel () == 1)
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 SparseComplexMatrix result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2817 if (im_val.nnz () == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2818 result = SparseComplexMatrix (re_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2819 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2820 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2821 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	2822 octave_idx_type nr = re_val.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2823 octave_idx_type nc = re_val.cols ();
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 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	2826 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2827 octave_idx_type off = j * nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2828 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	2829 i < re_val.cidx(j + 1); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2830 result.data (re_val.ridx(i) + off) =
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2831 result.data (re_val.ridx(i) + off) +
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2832 re_val.data (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2833 }
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 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	2836 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2837 else
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 if (re_val.dims () == im_val.dims ())
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 SparseComplexMatrix result = SparseComplexMatrix(re_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2842 + Complex(0, 1) * SparseComplexMatrix (im_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2843 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	2844 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2845 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2846 error ("complex: dimension mismatch");
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 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2850 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	2851 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2852 if (re.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2853 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2854 float re_val = re.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2855
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2856 if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2857 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2858 float im_val = im.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2859
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2860 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2861 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	2862 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2863 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2864 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2865 const FloatNDArray im_val = im.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2866
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2867 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2868 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2869 FloatComplexNDArray result (im_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2870
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2871 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	2872 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	2873
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2874 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	2875 }
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 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2878 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2879 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2880 const FloatNDArray re_val = re.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2881
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2882 if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2883 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2884 float im_val = im.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2885
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2886 if (! error_state)
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 FloatComplexNDArray result (re_val.dims (), FloatComplex ());
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 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	2891 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	2892
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2893 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	2894 }
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 else
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 const FloatNDArray im_val = im.float_array_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 if (re_val.dims () == im_val.dims ())
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 FloatComplexNDArray result (re_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2905
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2906 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	2907 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	2908
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2909 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	2910 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2911 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2912 error ("complex: dimension mismatch");
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 }
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 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2917 else if (re.numel () == 1)
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2918 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2919 double re_val = re.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2920
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2921 if (im.numel () == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2922 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2923 double im_val = im.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2924
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2925 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2926 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	2927 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2928 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2929 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2930 const NDArray im_val = im.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2931
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2932 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2933 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2934 ComplexNDArray result (im_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2935
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2936 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	2937 result.xelem (i) = Complex (re_val, im_val(i));
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 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2940 }
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 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2943 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2944 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2945 const NDArray re_val = re.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2946
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2947 if (im.numel () == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2948 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2949 double im_val = im.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2950
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2951 if (! error_state)
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 ComplexNDArray result (re_val.dims (), Complex ());
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 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	2956 result.xelem (i) = Complex (re_val(i), im_val);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2957
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2958 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2959 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2960 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2961 else
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 const NDArray im_val = im.array_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 if (re_val.dims () == im_val.dims ())
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 ComplexNDArray result (re_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2970
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2971 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	2972 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	2973
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2974 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2975 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2976 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2977 error ("complex: dimension mismatch");
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 }
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
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2982 if (error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2983 error ("complex: invalid conversion");
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 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2986 print_usage ();
5476 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 return retval;
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
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2991 DEFUN (isreal, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2992 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2993 @deftypefn {Built-in Function} {} isreal (@var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2994 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	2995 @end deftypefn")
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2996 {
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2997 octave_value retval;
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2998
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2999 if (args.length () == 1)
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3000 retval = args(0).is_real_type ();
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3001 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3002 print_usage ();
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3003
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3004 return retval;
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3005 }
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3006
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3007 DEFUN (isempty, args, ,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3008 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3009 @deftypefn {Built-in Function} {} isempty (@var{a})\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3010 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	3011 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	3012 @end deftypefn")
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3013 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3014 octave_value retval = false;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3015
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3016 if (args.length () == 1)
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	3017 retval = args(0).is_empty ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3018 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3019 print_usage ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3020
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3021 return retval;
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3022 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3023
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3024 DEFUN (isnumeric, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3025 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3026 @deftypefn {Built-in Function} {} isnumeric (@var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3027 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	3028 @end deftypefn")
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3029 {
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3030 octave_value retval;
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3031
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3032 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3033 retval = args(0).is_numeric_type ();
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3034 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3035 print_usage ();
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3036
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3037 return retval;
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3038 }
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3039
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3040 DEFUN (islist, args, ,
3526 cc21933776a1 [project @ 2000-02-02 10:53:27 by jwe] jwe parents: 3523 diff changeset	3041 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3042 @deftypefn {Built-in Function} {} islist (@var{x})\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3043 Return nonzero if @var{x} is a list.\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3044 @end deftypefn")
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3045 {
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3046 octave_value retval;
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3047
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3048 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3049 retval = args(0).is_list ();
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3050 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3051 print_usage ();
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3052
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3053 return retval;
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3054 }
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3055
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3056 DEFUN (ismatrix, args, ,
3321 6923abb04e16 [project @ 1999-10-26 18:15:30 by jwe] jwe parents: 3307 diff changeset	3057 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3058 @deftypefn {Built-in Function} {} ismatrix (@var{a})\n\
3321 6923abb04e16 [project @ 1999-10-26 18:15:30 by jwe] jwe parents: 3307 diff changeset	3059 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	3060 @end deftypefn")
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3061 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3062 octave_value retval = false;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3063
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3064 if (args.length () == 1)
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3065 {
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3066 octave_value arg = args(0);
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3067
3212 bf61c443a366 [project @ 1998-11-05 04:24:45 by jwe] jwe parents: 3209 diff changeset	3068 if (arg.is_scalar_type () \|\| arg.is_range ())
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3069 retval = true;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3070 else if (arg.is_matrix_type ())
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3071 retval = (arg.rows () >= 1 && arg.columns () >= 1);
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3072 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3073 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3074 print_usage ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3075
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3076 return retval;
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
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3079 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3080
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3081 %!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	3082 %!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	3083 %!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	3084
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3085 %% 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	3086 %!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	3087
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3088 %!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	3089 %!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	3090 %!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	3091
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3092 %% 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	3093 %!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	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 ("t"), false);
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 ("test"), false);
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 (["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	3098
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3099 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3100 %! 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	3101 %! 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	3102
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3103 %!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	3104 %!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	3105
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3106 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3107
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3108 static octave_value
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3109 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	3110 {
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3111 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3112
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3113 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3114
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3115 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	3116
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3117 dim_vector dims (1, 1);
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3118
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3119 if (nargin > 0 && args(nargin-1).is_string ())
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3120 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3121 std::string nm = args(nargin-1).string_value ();
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3122 nargin--;
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3123
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3124 dt = oct_data_conv::string_to_data_type (nm);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3125
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3126 if (error_state)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3127 return retval;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3128 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3129
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3130 switch (nargin)
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3131 {
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	3132 case 0:
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	3133 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3134
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	3135 case 1:
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3136 get_dimensions (args(0), fcn, dims);
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	3137 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3138
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3139 default:
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3140 {
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3141 dims.resize (nargin);
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3142
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3143 for (int i = 0; i < nargin; i++)
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3144 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3145 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	3146
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3147 if (error_state)
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3148 {
4732 b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	3149 error ("%s: expecting scalar integer arguments", fcn);
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3150 break;
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3151 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3152 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3153 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3154 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3155 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3156
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3157 if (! error_state)
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3158 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3159 dims.chop_trailing_singletons ();
4565 1db951a4fcd5 [project @ 2003-10-29 13:49:30 by jwe] jwe parents: 4563 diff changeset	3160
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3161 check_dimensions (dims, fcn);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3162
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	3163 // FIXME -- perhaps this should be made extensible by
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3164 // 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	3165 // the new value.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3166
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3167 // Note that automatic narrowing will handle conversion from
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3168 // NDArray to scalar.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3169
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3170 if (! error_state)
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3171 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3172 switch (dt)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3173 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3174 case oct_data_conv::dt_int8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3175 retval = int8NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3176 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3177
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3178 case oct_data_conv::dt_uint8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3179 retval = uint8NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3180 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3181
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3182 case oct_data_conv::dt_int16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3183 retval = int16NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3184 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3185
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3186 case oct_data_conv::dt_uint16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3187 retval = uint16NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3188 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3189
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3190 case oct_data_conv::dt_int32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3191 retval = int32NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3192 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3193
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3194 case oct_data_conv::dt_uint32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3195 retval = uint32NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3196 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3197
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3198 case oct_data_conv::dt_int64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3199 retval = int64NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3200 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3201
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3202 case oct_data_conv::dt_uint64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3203 retval = uint64NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3204 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3205
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3206 case oct_data_conv::dt_single:
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3207 retval = FloatNDArray (dims, val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3208 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3209
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3210 case oct_data_conv::dt_double:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3211 retval = NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3212 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3213
4986 fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3214 case oct_data_conv::dt_logical:
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3215 retval = boolNDArray (dims, val);
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3216 break;
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3217
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3218 default:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3219 error ("%s: invalid class name", fcn);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3220 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3221 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3222 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3223 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3224
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3225 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3226 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3227
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3228 static octave_value
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3229 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	3230 const char *fcn)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3231 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3232 octave_value retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3233
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3234 int nargin = args.length ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3235
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3236 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	3237
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3238 dim_vector dims (1, 1);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3239
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3240 if (nargin > 0 && args(nargin-1).is_string ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3241 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3242 std::string nm = args(nargin-1).string_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3243 nargin--;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3244
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3245 dt = oct_data_conv::string_to_data_type (nm);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3246
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3247 if (error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3248 return retval;
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
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3251 switch (nargin)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3252 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3253 case 0:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3254 break;
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 case 1:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3257 get_dimensions (args(0), fcn, dims);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3258 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3259
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3260 default:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3261 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3262 dims.resize (nargin);
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 for (int i = 0; i < nargin; i++)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3265 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3266 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	3267
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3268 if (error_state)
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 error ("%s: expecting scalar integer arguments", fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3271 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3272 }
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 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3275 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3276 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3277
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3278 if (! error_state)
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.chop_trailing_singletons ();
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 check_dimensions (dims, fcn);
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 // Note that automatic narrowing will handle conversion from
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3285 // NDArray to scalar.
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 if (! error_state)
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 switch (dt)
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 case oct_data_conv::dt_single:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3292 retval = FloatNDArray (dims, fval);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3293 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3294
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3295 case oct_data_conv::dt_double:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3296 retval = NDArray (dims, val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3297 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3298
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3299 default:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3300 error ("%s: invalid class name", fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3301 break;
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 }
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
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3306 return retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3307 }
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 static octave_value
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3310 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	3311 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3312 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3313
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3314 int nargin = args.length ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3315
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3316 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	3317
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3318 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3319
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3320 if (nargin > 0 && args(nargin-1).is_string ())
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3321 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3322 std::string nm = args(nargin-1).string_value ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3323 nargin--;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3324
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3325 dt = oct_data_conv::string_to_data_type (nm);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3326
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3327 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3328 return retval;
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
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3331 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3332 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3333 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3334 break;
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 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3337 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3338 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3339
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3340 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3341 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3342 dims.resize (nargin);
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 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3345 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3346 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	3347
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3348 if (error_state)
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 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3351 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3352 }
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 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3355 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3356 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3357
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3358 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3359 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3360 dims.chop_trailing_singletons ();
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 check_dimensions (dims, fcn);
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 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3365 // NDArray to scalar.
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 if (! error_state)
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 switch (dt)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3370 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3371 case oct_data_conv::dt_single:
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3372 retval = FloatNDArray (dims, static_cast <float> (val));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3373 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3374
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3375 case oct_data_conv::dt_double:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3376 retval = NDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3377 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3378
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3379 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3380 error ("%s: invalid class name", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3381 break;
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 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3384 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3385
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3386 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3387 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3388
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3389 static octave_value
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3390 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	3391 const char *fcn)
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 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3394
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3395 int nargin = args.length ();
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 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	3398
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3399 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3400
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3401 if (nargin > 0 && args(nargin-1).is_string ())
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 std::string nm = args(nargin-1).string_value ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3404 nargin--;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3405
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3406 dt = oct_data_conv::string_to_data_type (nm);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3407
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3408 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3409 return retval;
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
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3412 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3413 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3414 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3415 break;
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 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3418 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3419 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3420
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3421 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3422 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3423 dims.resize (nargin);
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 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3426 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3427 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	3428
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3429 if (error_state)
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 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3432 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3433 }
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 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3436 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3437 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3438
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3439 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3440 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3441 dims.chop_trailing_singletons ();
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 check_dimensions (dims, fcn);
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 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3446 // NDArray to scalar.
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 if (! error_state)
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 switch (dt)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3451 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3452 case oct_data_conv::dt_single:
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3453 retval = FloatComplexNDArray (dims, static_cast<FloatComplex> (val));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3454 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3455
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3456 case oct_data_conv::dt_double:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3457 retval = ComplexNDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3458 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3459
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3460 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3461 error ("%s: invalid class name", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3462 break;
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 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3465 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3466
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3467 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3468 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3469
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3470 static octave_value
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3471 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	3472 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3473 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3474
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3475 int nargin = args.length ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3476
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3477 dim_vector dims (1, 1);
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 switch (nargin)
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 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3482 break;
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 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3485 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3486 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3487
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3488 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3489 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3490 dims.resize (nargin);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3491
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3492 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3493 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3494 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	3495
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3496 if (error_state)
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 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3499 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3500 }
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 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3503 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3504 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3505
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3506 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3507 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3508 dims.chop_trailing_singletons ();
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 check_dimensions (dims, fcn);
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 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3513 // NDArray to scalar.
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 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3516 retval = boolNDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3517 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3518
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3519 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3520 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3521
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3522 DEFUN (ones, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3523 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3524 @deftypefn {Built-in Function} {} ones (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3525 @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	3526 @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	3527 @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	3528 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	3529 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	3530 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3531 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	3532 use an expression like\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3533 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3534 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3535 val_matrix = val * ones (n, m)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3536 @end example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3537 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3538 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	3539 the specified type, for example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3540 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3541 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3542 val = ones (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3543 @end example\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3544 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3545 {
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3546 return fill_matrix (args, 1, "ones");
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3547 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3548
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3549 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3550
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3551 %!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	3552 %!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	3553 %!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	3554 %!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	3555
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3556 %!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	3557 %!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	3558 %!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	3559 %!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	3560
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3561 %!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	3562 %!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	3563 %!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	3564 %!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	3565
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3566 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3567
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3568 DEFUN (zeros, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3569 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3570 @deftypefn {Built-in Function} {} zeros (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3571 @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	3572 @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	3573 @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	3574 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	3575 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	3576 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3577 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	3578 the specified type, for example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3579 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3580 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3581 val = zeros (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3582 @end example\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3583 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3584 {
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3585 return fill_matrix (args, 0, "zeros");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3586 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3587
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3588 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3589
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3590 %!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	3591 %!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	3592 %!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	3593 %!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	3594
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3595 %!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	3596 %!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	3597 %!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	3598 %!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	3599
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3600 %!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	3601 %!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	3602 %!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	3603 %!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	3604
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3605 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3606
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3607 DEFUN (Inf, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3608 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3609 @deftypefn {Built-in Function} {} Inf (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3610 @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	3611 @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	3612 @deftypefnx {Built-in Function} {} Inf (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3613 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	3614 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	3615 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	3616 @samp{\"double\"}. The default is @samp{\"double\"}.\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3617 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3618 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3619 return fill_matrix (args, lo_ieee_inf_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3620 lo_ieee_float_inf_value (), "Inf");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3621 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3622
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3623 DEFALIAS (inf, Inf);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3624
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3625 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3626
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3627 %!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	3628 %!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	3629 %!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	3630 %!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	3631
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3632 %!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	3633 %!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	3634 %!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	3635 %!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	3636
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3637 %!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	3638 %!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	3639 %!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	3640 %!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	3641
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3642 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3643
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3644 DEFUN (NaN, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3645 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3646 @deftypefn {Built-in Function} {} NaN (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3647 @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	3648 @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	3649 @deftypefnx {Built-in Function} {} NaN (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3650 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	3651 (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	3652 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3653 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3654 $0/0$, or $\\infty - \\infty$,\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3655 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3656 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3657 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3658 0/0, or @samp{Inf - Inf},\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3659 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3660 or any operation with a NaN.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3661 \n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3662 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	3663 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	3664 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	3665 \n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3666 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	3667 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	3668 @samp{\"double\"}. The default is @samp{\"double\"}.\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3669 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3670 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3671 return fill_matrix (args, lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3672 lo_ieee_float_nan_value (), "NaN");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3673 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3674
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3675 DEFALIAS (nan, NaN);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3676
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3677 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3678 %!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	3679 %!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	3680 %!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	3681 %!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	3682
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3683 %!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	3684 %!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	3685 %!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	3686 %!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	3687
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3688 %!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	3689 %!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	3690 %!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	3691 %!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	3692
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3693 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3694
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3695 DEFUN (e, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3696 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3697 @deftypefn {Built-in Function} {} e (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3698 @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	3699 @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	3700 @deftypefnx {Built-in Function} {} e (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3701 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	3702 to the base of natural logarithms. The constant\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3703 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3704 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3705 $e$\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3706 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3707 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3708 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3709 @var{e}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3710 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3711 satisfies the equation\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3712 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3713 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3714 $\\log (e) = 1$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3715 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3716 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3717 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3718 @code{log} (@var{e}) = 1.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3719 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3720 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3721 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3722 #if defined (M_E)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3723 double e_val = M_E;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3724 #else
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3725 double e_val = exp (1.0);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3726 #endif
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3727
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3728 return fill_matrix (args, e_val, "e");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3729 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3730
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3731 DEFUN (eps, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3732 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3733 @deftypefn {Built-in Function} {} eps (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3734 @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	3735 @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	3736 @deftypefnx {Built-in Function} {} eps (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3737 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	3738 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	3739 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	3740 floating point system. This number is obviously system-dependent. On\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3741 machines that support 64 bit IEEE floating point arithmetic, @code{eps}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3742 is approximately\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3743 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3744 2.2204e-16.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3745 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3746 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3747 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3748 $2.2204\\times10^{-16}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3749 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3750 @end iftex\n\
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3751 for double precision and\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3752 @ifinfo\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3753 1.1921e-07.\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3754 @end ifinfo\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3755 @iftex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3756 @tex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3757 $1.1921\\times10^{-7}$.\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3758 @end tex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3759 @end iftex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3760 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	3761 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	3762 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3763 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3764 int nargin = args.length ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3765 octave_value retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3766
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3767 if (nargin == 1 && ! args(0).is_string ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3768 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3769 if (args(0).is_single_type ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3770 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3771 float val = args(0).float_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3772
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3773 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3774 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3775 val = ::fabsf(val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3776 if (xisnan (val) \|\| xisinf (val))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3777 retval = fill_matrix (octave_value ("single"),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3778 lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3779 lo_ieee_float_nan_value (), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3780 else if (val < FLT_MIN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3781 retval = fill_matrix (octave_value ("single"), 0e0,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3782 powf (2.0, -149e0), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3783 else
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 int expon;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3786 frexpf (val, &expon);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3787 val = std::pow (static_cast <float> (2.0),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3788 static_cast <float> (expon - 24));
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3789 retval = fill_matrix (octave_value ("single"), DBL_EPSILON,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3790 val, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3791 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3792 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3793 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3794 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3795 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3796 double val = args(0).double_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3797
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3798 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3799 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3800 val = ::fabs(val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3801 if (xisnan (val) \|\| xisinf (val))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3802 retval = fill_matrix (octave_value_list (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3803 lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3804 lo_ieee_float_nan_value (), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3805 else if (val < DBL_MIN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3806 retval = fill_matrix (octave_value_list (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3807 pow (2.0, -1074e0), 0e0, "eps");
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 int expon;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3811 frexp (val, &expon);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3812 val = std::pow (static_cast <double> (2.0),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3813 static_cast <double> (expon - 53));
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3814 retval = fill_matrix (octave_value_list (), val,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3815 FLT_EPSILON, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3816 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3817 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3818 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3819 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3820 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3821 retval = fill_matrix (args, DBL_EPSILON, FLT_EPSILON, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3822
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3823 return retval;
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3824 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3825
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3826 /*
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3827
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3828 %!assert(eps(1/2),2^(-53))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3829 %!assert(eps(1),2^(-52))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3830 %!assert(eps(2),2^(-51))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3831 %!assert(eps(realmax),2^971)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3832 %!assert(eps(0),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3833 %!assert(eps(realmin/2),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3834 %!assert(eps(realmin/16),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3835 %!assert(eps(Inf),NaN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3836 %!assert(eps(NaN),NaN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3837 %!assert(eps(single(1/2)),single(2^(-24)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3838 %!assert(eps(single(1)),single(2^(-23)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3839 %!assert(eps(single(2)),single(2^(-22)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3840 %!assert(eps(realmax('single')),single(2^104))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3841 %!assert(eps(single(0)),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3842 %!assert(eps(realmin('single')/2),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3843 %!assert(eps(realmin('single')/16),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3844 %!assert(eps(single(Inf)),single(NaN))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3845 %!assert(eps(single(NaN)),single(NaN))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3846
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3847 */
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3848
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3849
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3850 DEFUN (pi, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3851 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3852 @deftypefn {Built-in Function} {} pi (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3853 @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	3854 @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	3855 @deftypefnx {Built-in Function} {} pi (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3856 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	3857 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	3858 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	3859 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3860 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3861 #if defined (M_PI)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3862 double pi_val = M_PI;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3863 #else
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3864 double pi_val = 4.0 * atan (1.0);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3865 #endif
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3866
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3867 return fill_matrix (args, pi_val, "pi");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3868 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3869
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3870 DEFUN (realmax, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3871 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3872 @deftypefn {Built-in Function} {} realmax (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3873 @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	3874 @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	3875 @deftypefnx {Built-in Function} {} realmax (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3876 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	3877 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	3878 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	3879 floating point arithmetic, @code{realmax} is approximately\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3880 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3881 1.7977e+308\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3882 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3883 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3884 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3885 $1.7977\\times10^{308}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3886 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3887 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3888 @seealso{realmin}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3889 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3890 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3891 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	3892 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3893
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3894 DEFUN (realmin, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3895 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3896 @deftypefn {Built-in Function} {} realmin (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3897 @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	3898 @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	3899 @deftypefnx {Built-in Function} {} realmin (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3900 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	3901 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	3902 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	3903 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	3904 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3905 2.2251e-308\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3906 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3907 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3908 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3909 $2.2251\\times10^{-308}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3910 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3911 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3912 @seealso{realmax}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3913 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3914 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3915 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	3916 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3917
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3918 DEFUN (I, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3919 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3920 @deftypefn {Built-in Function} {} I (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3921 @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	3922 @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	3923 @deftypefnx {Built-in Function} {} I (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3924 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	3925 to the pure imaginary unit, defined as\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3926 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3927 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3928 $\\sqrt{-1}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3929 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3930 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3931 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3932 @code{sqrt (-1)}.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3933 @end ifinfo\n\
7001 8b0cfeb06365 [project @ 2007-10-10 18:02:59 by jwe] jwe parents: 6999 diff changeset	3934 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	3935 other purposes.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3936 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3937 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3938 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	3939 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3940
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3941 DEFALIAS (i, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3942 DEFALIAS (J, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3943 DEFALIAS (j, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3944
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3945 DEFUN (NA, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3946 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3947 @deftypefn {Built-in Function} {} NA (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3948 @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	3949 @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	3950 @deftypefnx {Built-in Function} {} NA (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3951 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	3952 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	3953 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3954 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3955 return fill_matrix (args, lo_ieee_na_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3956 lo_ieee_float_na_value (), "NA");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3957 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3958
7991 139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3959 /*
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3960
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3961 %!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	3962 %!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	3963
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3964 */
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3965
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3966 DEFUN (false, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3967 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3968 @deftypefn {Built-in Function} {} false (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3969 @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	3970 @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	3971 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	3972 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	3973 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3974 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3975 return fill_matrix (args, false, "false");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3976 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3977
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3978 DEFUN (true, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3979 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3980 @deftypefn {Built-in Function} {} true (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3981 @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	3982 @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	3983 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	3984 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	3985 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3986 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3987 return fill_matrix (args, true, "true");
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3988 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3989
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3990 template <class MT>
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3991 octave_value
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3992 identity_matrix (int nr, int nc)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3993 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3994 octave_value retval;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3995
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3996 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	3997
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3998 if (nr == 1 && nc == 1)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3999 retval = one;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4000 else
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4001 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4002 dim_vector dims (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4003
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4004 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	4005
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4006 MT m (dims, zero);
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 if (nr > 0 && nc > 0)
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 int n = std::min (nr, nc);
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 for (int i = 0; i < n; i++)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4013 m(i,i) = one;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4014 }
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 retval = m;
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
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4019 return retval;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4020 }
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4021
5058 11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4022 #define INSTANTIATE_EYE(T) \
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4023 template octave_value identity_matrix<T> (int, int)
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4024
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4025 INSTANTIATE_EYE (int8NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4026 INSTANTIATE_EYE (uint8NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4027 INSTANTIATE_EYE (int16NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4028 INSTANTIATE_EYE (uint16NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4029 INSTANTIATE_EYE (int32NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4030 INSTANTIATE_EYE (uint32NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4031 INSTANTIATE_EYE (int64NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4032 INSTANTIATE_EYE (uint64NDArray);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4033 INSTANTIATE_EYE (FloatNDArray);
5058 11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4034 INSTANTIATE_EYE (NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4035 INSTANTIATE_EYE (boolNDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4036
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4037 static octave_value
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4038 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	4039 {
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4040 octave_value retval;
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4041
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4042 // 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	4043 // 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	4044 // value.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4045
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4046 if (! error_state)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4047 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4048 switch (dt)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4049 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4050 case oct_data_conv::dt_int8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4051 retval = identity_matrix<int8NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4052 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4053
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4054 case oct_data_conv::dt_uint8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4055 retval = identity_matrix<uint8NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4056 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4057
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4058 case oct_data_conv::dt_int16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4059 retval = identity_matrix<int16NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4060 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4061
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4062 case oct_data_conv::dt_uint16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4063 retval = identity_matrix<uint16NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4064 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4065
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4066 case oct_data_conv::dt_int32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4067 retval = identity_matrix<int32NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4068 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4069
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4070 case oct_data_conv::dt_uint32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4071 retval = identity_matrix<uint32NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4072 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4073
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4074 case oct_data_conv::dt_int64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4075 retval = identity_matrix<int64NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4076 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4077
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4078 case oct_data_conv::dt_uint64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4079 retval = identity_matrix<uint64NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4080 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4081
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4082 case oct_data_conv::dt_single:
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4083 retval = identity_matrix<FloatNDArray> (nr, nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4084 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4085
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4086 case oct_data_conv::dt_double:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4087 retval = identity_matrix<NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4088 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4089
4986 fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4090 case oct_data_conv::dt_logical:
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4091 retval = identity_matrix<boolNDArray> (nr, nc);
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4092 break;
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4093
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4094 default:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4095 error ("eye: invalid class name");
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4096 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4097 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4098 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4099
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4100 return retval;
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4101 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4102
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4103 #undef INT_EYE_MATRIX
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4104
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	4105 DEFUN (eye, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4106 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4107 @deftypefn {Built-in Function} {} eye (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4108 @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	4109 @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	4110 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	4111 @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	4112 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	4113 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	4114 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	4115 respectively. For example,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4116 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4117 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4118 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4119 eye (3)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4120 @result{} 1 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4121 0 1 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4122 0 0 1\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4123 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4124 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4125 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4126 The following expressions all produce the same result:\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4127 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4128 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4129 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4130 eye (2)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4131 @equiv{}\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4132 eye (2, 2)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4133 @equiv{}\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4134 eye (size ([1, 2; 3, 4])\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4135 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4136 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4137 \n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4138 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	4139 the specified type, like\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4140 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4141 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4142 val = zeros (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4143 @end example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4144 \n\
6556 8810bbf321ce [project @ 2007-04-20 18:39:40 by jwe] jwe parents: 6518 diff changeset	4145 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	4146 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	4147 with @sc{Matlab}.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4148 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4149 {
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4150 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4151
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4152 int nargin = args.length ();
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4153
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4154 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	4155
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4156 // Check for type information.
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4157
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4158 if (nargin > 0 && args(nargin-1).is_string ())
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4159 {
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4160 std::string nm = args(nargin-1).string_value ();
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4161 nargin--;
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4162
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4163 dt = oct_data_conv::string_to_data_type (nm);
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4164
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4165 if (error_state)
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4166 return retval;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4167 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4168
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4169 switch (nargin)
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4170 {
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	4171 case 0:
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4172 retval = identity_matrix (1, 1, dt);
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	4173 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4174
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	4175 case 1:
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4176 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4177 octave_idx_type nr, nc;
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4178 get_dimensions (args(0), "eye", nr, nc);
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4179
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4180 if (! error_state)
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4181 retval = identity_matrix (nr, nc, dt);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4182 }
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	4183 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4184
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4185 case 2:
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4186 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4187 octave_idx_type nr, nc;
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4188 get_dimensions (args(0), args(1), "eye", nr, nc);
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4189
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4190 if (! error_state)
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4191 retval = identity_matrix (nr, nc, dt);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4192 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4193 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4194
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4195 default:
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4196 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4197 break;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4198 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4199
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4200 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4201 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4202
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4203
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4204 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4205
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4206 %!assert (eye(3), [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	4207 %!assert (eye(2, 3), [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	4208
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4209 %!assert (eye(3,'single'), single([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	4210 %!assert (eye(2, 3,'single'), single([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	4211
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4212 %!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	4213 %!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	4214
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4215 %!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	4216
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
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	4219 DEFUN (linspace, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4220 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4221 @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	4222 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	4223 @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	4224 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	4225 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	4226 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	4227 value of 100 is used.\n\
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4228 \n\
4455 abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4358 diff changeset	4229 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	4230 \n\
0fcc8d65b571 [project @ 2007-05-16 15:32:09 by jwe] jwe parents: 6561 diff changeset	4231 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	4232 fewer than two values are requested.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4233 @end deftypefn")
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4234 {
3418 ca92c9d3f882 [project @ 2000-01-12 03:07:47 by jwe] jwe parents: 3373 diff changeset	4235 octave_value retval;
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4236
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4237 int nargin = args.length ();
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4238
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4239 octave_idx_type npoints = 100;
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4240
1940 1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4241 if (nargin != 2 && nargin != 3)
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4242 {
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4243 print_usage ();
1940 1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4244 return retval;
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4245 }
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4246
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4247 if (nargin == 3)
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4248 npoints = args(2).idx_type_value ();
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4249
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4250 if (! error_state)
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4251 {
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4252 octave_value arg_1 = args(0);
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4253 octave_value arg_2 = args(1);
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4254
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4255 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	4256 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4257 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	4258 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4259 FloatComplex x1 = arg_1.float_complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4260 FloatComplex x2 = arg_2.float_complex_value ();
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4261
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4262 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4263 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4264 FloatComplexRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4265
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4266 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4267 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4268 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4269 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4270 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4271 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4272 float x1 = arg_1.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4273 float x2 = arg_2.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4274
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4275 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4276 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4277 FloatRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4278
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4279 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4280 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4281 }
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4282 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4283 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4284 else
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4285 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4286 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	4287 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4288 Complex x1 = arg_1.complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4289 Complex x2 = arg_2.complex_value ();
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4290
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4291 if (! error_state)
7789 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 ComplexRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4294
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4295 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4296 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4297 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4298 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4299 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4300 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4301 double x1 = arg_1.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4302 double x2 = arg_2.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4303
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4304 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4305 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4306 RowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4307
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4308 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4309 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4310 }
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4311 }
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4312 }
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4313 }
4732 b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	4314 else
b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	4315 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	4316
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4317 return retval;
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4318 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4319
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4320
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4321 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4322
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4323 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4324 %! 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	4325 %! 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	4326 %! 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	4327 %! 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	4328 %! && 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	4329 %! && 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	4330
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4331
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4332 % 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	4333
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4334 %!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	4335 %!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	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 %! 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	4339
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4340 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4341
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4342 // 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	4343 // 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	4344
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4345 DEFUN (resize, args, ,
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4346 "-- texinfo --\n\
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4347 @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	4348 @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	4349 Destructively resize @var{x}.\n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4350 \n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4351 @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	4352 @code{reshape}.}\n\
6174 d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4353 \n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4354 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	4355 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	4356 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	4357 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	4358 the result are @var{m}-by-@var{n}.\n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4359 @seealso{reshape}\n\
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4360 @end deftypefn")
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4361 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4362 octave_value retval;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4363 int nargin = args.length ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4364
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4365 if (nargin == 2)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4366 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4367 Array<double> vec = args(1).vector_value ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4368 int ndim = vec.length ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4369 if (ndim == 1)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4370 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4371 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	4372 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4373 retval = retval.resize (dim_vector (m, m), true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4374 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4375 else
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4376 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4377 dim_vector dv;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4378 dv.resize (ndim);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4379 for (int i = 0; i < ndim; i++)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4380 dv(i) = static_cast<octave_idx_type> (vec(i));
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4381 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4382 retval = retval.resize (dv, true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4383 }
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 else if (nargin == 3)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4386 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4387 octave_idx_type m = static_cast<octave_idx_type>
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4388 (args(1).scalar_value());
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4389 octave_idx_type n = static_cast<octave_idx_type>
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4390 (args(2).scalar_value());
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4391 if (!error_state)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4392 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4393 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4394 retval = retval.resize (dim_vector (m, n), true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4395 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4396 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4397 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4398 print_usage ();
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4399 return retval;
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
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4402 // FIXME -- should use octave_idx_type for dimensions.
5734 a7d2c47371d2 [project @ 2006-04-04 18:29:13 by jwe] jwe parents: 5731 diff changeset	4403
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4404 DEFUN (reshape, args, ,
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4405 "-- texinfo --\n\
6671 9042b00fc45e [project @ 2007-05-30 06:33:29 by jwe] jwe parents: 6630 diff changeset	4406 @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	4407 @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	4408 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	4409 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	4410 column-major order (like Fortran arrays are stored).\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4411 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4412 For example,\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4413 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4414 @example\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4415 @group\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4416 reshape ([1, 2, 3, 4], 2, 2)\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4417 @result{} 1 3\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4418 2 4\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4419 @end group\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4420 @end example\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4421 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4422 @noindent\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4423 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	4424 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	4425 \n\
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4426 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	4427 by an empty argument.\n\
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4428 @end deftypefn")
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4429 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4430 octave_value retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4431
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4432 int nargin = args.length ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4433
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4434 Array<int> new_size;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4435
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4436 if (nargin == 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4437 new_size = args(1).int_vector_value ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4438 else if (nargin > 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4439 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4440 new_size.resize (nargin-1);
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4441 int empty_dim = -1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4442
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4443 for (int i = 1; i < nargin; i++)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4444 {
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4445 if (args(i).is_empty ())
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4446 if (empty_dim > 0)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4447 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4448 error ("reshape: only a single dimension can be unknown");
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4449 break;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4450 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4451 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4452 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4453 empty_dim = i;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4454 new_size(i-1) = 1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4455 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4456 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4457 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4458 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	4459
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4460 if (error_state)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4461 break;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4462 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4463 }
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 if (! error_state && (empty_dim > 0))
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 int nel = 1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4468 for (int i = 0; i < nargin - 1; i++)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4469 nel *= new_size(i);
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4470
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4471 if (nel == 0)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4472 new_size(empty_dim-1) = 0;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4473 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4474 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4475 int size_empty_dim = args(0).numel () / nel;
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 if (args(0).numel () != size_empty_dim * nel)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4478 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	4479 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4480 new_size(empty_dim-1) = size_empty_dim;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4481 }
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4482 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4483 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4484 else
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4485 {
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4486 print_usage ();
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4487 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4488 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4489
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4490 if (error_state)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4491 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4492 error ("reshape: invalid arguments");
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4493 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4494 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4495
4739 7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4496 // 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	4497 // elements.
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4498
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4499 int n = new_size.length ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4500
4739 7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4501 while (n > 2)
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4502 {
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4503 if (new_size(n-1) == 1)
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4504 n--;
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4505 else
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4506 break;
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4507 }
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4508
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4509 new_size.resize (n);
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4510
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4511 if (n < 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4512 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4513 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	4514 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4515 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4516
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4517 dim_vector new_dims;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4518
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4519 new_dims.resize (n);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4520
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4521 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	4522 new_dims(i) = new_size(i);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4523
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4524 octave_value arg = args(0);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4525
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4526 if (new_dims.numel () == arg.numel ())
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4527 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	4528 else
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4529 error ("reshape: size mismatch");
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 return retval;
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
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4534 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4535
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4536 %!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	4537 %!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	4538 %!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	4539 %!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	4540
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4541 %!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	4542 %!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	4543 %!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	4544 %!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	4545
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4546 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4547 %! 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	4548 %! 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	4549
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4550 %!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	4551 %!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	4552
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4553 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4554
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4555 DEFUN (squeeze, args, ,
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4556 "-- texinfo --\n\
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4557 @deftypefn {Built-in Function} {} squeeze (@var{x})\n\
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4558 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	4559 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	4560 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	4561 @end deftypefn")
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4562 {
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4563 octave_value retval;
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4564
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4565 if (args.length () == 1)
4545 c16f153836a0 [project @ 2003-10-24 04:45:45 by jwe] jwe parents: 4532 diff changeset	4566 retval = args(0).squeeze ();
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4567 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4568 print_usage ();
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4569
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4570 return retval;
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4571 }
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4572
6945 6bbf56a9718a [project @ 2007-10-02 20:47:22 by jwe] jwe parents: 6887 diff changeset	4573 // Compute various norms of the vector X.
6bbf56a9718a [project @ 2007-10-02 20:47:22 by jwe] jwe parents: 6887 diff changeset	4574
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4575 DEFUN (norm, args, ,
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4576 "-- texinfo --\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4577 @deftypefn {Function File} {} norm (@var{a}, @var{p})\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4578 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	4579 missing, @code{p = 2} is assumed.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4580 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4581 If @var{a} is a matrix:\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4582 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4583 @table @asis\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4584 @item @var{p} = @code{1}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4585 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	4586 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4587 @item @var{p} = @code{2}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4588 Largest singular value of @var{a}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4589 \n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4590 @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	4591 @cindex infinity norm\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4592 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	4593 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4594 @item @var{p} = @code{\"fro\"}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4595 @cindex Frobenius norm\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4596 Frobenius norm of @var{a}, @code{sqrt (sum (diag (@var{a}' * @var{a})))}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4597 @end table\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4598 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4599 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	4600 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4601 @table @asis\n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4602 @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	4603 @code{max (abs (@var{a}))}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4604 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4605 @item @var{p} = @code{-Inf}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4606 @code{min (abs (@var{a}))}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4607 \n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4608 @item @var{p} = @code{\"fro\"}\n\
e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4609 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	4610 \n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4611 @item other\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4612 p-norm of @var{a}, @code{(sum (abs (@var{a}) .^ @var{p})) ^ (1/@var{p})}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4613 @end table\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4614 @seealso{cond, svd}\n\
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4615 @end deftypefn")
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4616 {
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4617 // Currently only handles vector norms for full double/complex
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4618 // vectors internally. Other cases are handled by __norm__.m.
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4619
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4620 octave_value_list retval;
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4621
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4622 int nargin = args.length ();
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4623
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4624 if (nargin == 1 \|\| nargin == 2)
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4625 {
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4626 octave_value x_arg = args(0);
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4627
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4628 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	4629 {
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4630 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	4631 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	4632 else
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4633 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	4634 }
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4635 else if (x_arg.ndims () == 2)
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4636 {
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4637 if ((x_arg.rows () == 1 \|\| x_arg.columns () == 1)
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4638 && ! (x_arg.is_sparse_type () \|\| x_arg.is_integer_type ()))
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4639 {
7093 e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4640 double p_val = 2;
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4641
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4642 if (nargin == 2)
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4643 {
7093 e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4644 octave_value p_arg = args(1);
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4645
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4646 if (p_arg.is_string ())
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4647 {
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4648 std::string p = args(1).string_value ();
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4649
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4650 if (p == "inf")
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4651 p_val = octave_Inf;
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4652 else if (p == "fro")
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4653 p_val = -1;
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4654 else
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4655 error ("norm: unrecognized norm `%s'", p.c_str ());
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4656 }
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4657 else
7093 e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4658 {
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4659 p_val = p_arg.double_value ();
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4660
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4661 if (error_state)
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4662 error ("norm: unrecognized norm value");
e5005117103d [project @ 2007-10-31 23:41:37 by jwe] jwe parents: 7078 diff changeset	4663 }
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4664 }
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4665
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4666 if (x_arg.is_single_type ())
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4667 {
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4668 if (! error_state)
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4669 {
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4670 if (x_arg.is_real_type ())
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 MArray<float> x (x_arg.float_array_value ());
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4673
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4674 if (! error_state)
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) = x.norm (static_cast<float>(p_val));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4676 else
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4677 error ("norm: expecting real vector");
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4678 }
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4679 else
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4680 {
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4681 MArray<FloatComplex> x (x_arg.float_complex_array_value ());
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4682
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4683 if (! error_state)
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4684 retval(0) = x.norm (static_cast<float>(p_val));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4685 else
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4686 error ("norm: expecting complex vector");
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4687 }
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4688 }
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4689 }
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4690 else
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4691 {
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4692 if (! error_state)
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4693 {
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4694 if (x_arg.is_real_type ())
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4695 {
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4696 MArray<double> x (x_arg.array_value ());
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4697
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4698 if (! error_state)
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4699 retval(0) = x.norm (p_val);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4700 else
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4701 error ("norm: expecting real vector");
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4702 }
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4703 else
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4704 {
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4705 MArray<Complex> x (x_arg.complex_array_value ());
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4706
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4707 if (! error_state)
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4708 retval(0) = x.norm (p_val);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4709 else
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4710 error ("norm: expecting complex vector");
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4711 }
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4712 }
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4713 }
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4714 }
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4715 else
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4716 retval = feval ("__norm__", args);
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4717 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4718 else
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4719 error ("norm: only valid for 2-D objects");
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4720 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4721 else
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4722 print_usage ();
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4723
7269 3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7231 diff changeset	4724 // Should not return a sparse type
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7231 diff changeset	4725 if (retval(0).is_sparse_type ())
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7231 diff changeset	4726 {
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7231 diff changeset	4727 if (retval(0).type_name () == "sparse matrix")
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7231 diff changeset	4728 retval(0) = retval(0).matrix_value ();
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7231 diff changeset	4729 else if (retval(0).type_name () == "sparse complex matrix")
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7231 diff changeset	4730 retval(0) = retval(0).complex_matrix_value ();
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7231 diff changeset	4731 else if (retval(0).type_name () == "sparse bool matrix")
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7231 diff changeset	4732 retval(0) = retval(0).bool_matrix_value ();
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7231 diff changeset	4733 }
3fade00a6ac7 [project @ 2007-12-07 19:26:20 by jwe] jwe parents: 7231 diff changeset	4734
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4735 return retval;
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4736 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4737
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4738 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4739 %!shared x
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4740 %! 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	4741 %!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	4742 %!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	4743 %!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	4744 %!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	4745 %!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	4746 %!assert(norm(x,"inf"), 7);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4747 %!assert(norm(x,"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	4748 %!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	4749 %!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	4750 %!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	4751 %!shared m
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4752 %! 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	4753 %!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	4754 %!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	4755 %!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	4756 %!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	4757 %!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	4758 %! 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	4759 %! 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	4760 %! 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	4761 %!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	4762 %!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	4763
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4764 %!shared x
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4765 %! 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	4766 %!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	4767 %!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	4768 %!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	4769 %!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	4770 %!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	4771 %!assert(norm(x,"inf"), single(7));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4772 %!assert(norm(x,"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	4773 %!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	4774 %!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	4775 %!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	4776 %!shared m
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4777 %! 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	4778 %!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	4779 %!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	4780 %!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	4781 %!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	4782 %!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	4783 %! 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	4784 %! 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	4785 %! 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	4786 %!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	4787 %!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	4788 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4789
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4790 #define UNARY_OP_DEFUN_BODY(F) \
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 octave_value 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 if (args.length () == 1) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4795 retval = F (args(0)); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4796 else \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4797 print_usage (); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4798 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4799 return retval
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4800
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4801 DEFUN (not, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4802 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4803 @deftypefn {Built-in Function} {} not (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4804 This function is equivalent to @code{! x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4805 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4806 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4807 UNARY_OP_DEFUN_BODY (op_not);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4810 DEFUN (uplus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4811 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4812 @deftypefn {Built-in Function} {} uplus (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4813 This function is equivalent to @code{+ x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4814 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4815 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4816 UNARY_OP_DEFUN_BODY (op_uplus);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4819 DEFUN (uminus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4820 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4821 @deftypefn {Built-in Function} {} uminus (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4822 This function is equivalent to @code{- x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4823 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4824 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4825 UNARY_OP_DEFUN_BODY (op_uminus);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4828 DEFUN (transpose, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4829 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4830 @deftypefn {Built-in Function} {} transpose (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4831 This function is equivalent to @code{x.'}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4832 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4833 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4834 UNARY_OP_DEFUN_BODY (op_transpose);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4835 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4836
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4837 /*
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 (2.', 2);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4840 %!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	4841 %!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	4842 %!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	4843 %!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	4844 %!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	4845
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4846 %!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	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 (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	4849 %!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	4850 %!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	4851 %!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	4852 %!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	4853 %!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	4854
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4855 %!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	4856
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4857 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4858
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4859 DEFUN (ctranspose, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4860 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4861 @deftypefn {Built-in Function} {} ctranspose (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4862 This function is equivalent to @code{x'}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4863 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4864 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4865 UNARY_OP_DEFUN_BODY (op_hermitian);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4866 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4867
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4868 /*
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 (2', 2);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4871 %!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	4872 %!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	4873 %!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	4874 %!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	4875 %!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	4876
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4877 %!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	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 (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	4880 %!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	4881 %!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	4882 %!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	4883 %!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	4884 %!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	4885
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4886 %!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	4887
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4888 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4889
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4890 #define BINARY_OP_DEFUN_BODY(F) \
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 octave_value 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 if (args.length () == 2) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4895 retval = F (args(0), args(1)); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4896 else \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4897 print_usage (); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4898 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4899 return retval
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4900
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4901 DEFUN (plus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4902 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4903 @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	4904 This function is equivalent to @code{x + y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4905 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4906 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4907 BINARY_OP_DEFUN_BODY (op_add);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4910 DEFUN (minus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4911 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4912 @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	4913 This function is equivalent to @code{x - y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4914 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4915 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4916 BINARY_OP_DEFUN_BODY (op_sub);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4919 DEFUN (mtimes, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4920 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4921 @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	4922 This function is equivalent to @code{x * y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4923 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4924 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4925 BINARY_OP_DEFUN_BODY (op_mul);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4928 DEFUN (mrdivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4929 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4930 @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	4931 This function is equivalent to @code{x / y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4932 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4933 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4934 BINARY_OP_DEFUN_BODY (op_div);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4937 DEFUN (mpower, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4938 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4939 @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	4940 This function is equivalent to @code{x ^ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4941 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4942 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4943 BINARY_OP_DEFUN_BODY (op_pow);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4946 DEFUN (mldivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4947 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4948 @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	4949 This function is equivalent to @code{x \\ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4950 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4951 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4952 BINARY_OP_DEFUN_BODY (op_ldiv);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4955 DEFUN (lt, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4956 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4957 @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	4958 This function is equivalent to @code{x < y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4959 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4960 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4961 BINARY_OP_DEFUN_BODY (op_lt);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4964 DEFUN (le, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4965 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4966 @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	4967 This function is equivalent to @code{x <= y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4968 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4969 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4970 BINARY_OP_DEFUN_BODY (op_le);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4973 DEFUN (eq, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4974 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4975 @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	4976 This function is equivalent to @code{x == y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4977 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4978 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4979 BINARY_OP_DEFUN_BODY (op_eq);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4982 DEFUN (ge, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4983 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4984 @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	4985 This function is equivalent to @code{x >= y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4986 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4987 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4988 BINARY_OP_DEFUN_BODY (op_ge);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4991 DEFUN (gt, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4992 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4993 @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	4994 This function is equivalent to @code{x > y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4995 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4996 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4997 BINARY_OP_DEFUN_BODY (op_gt);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5000 DEFUN (ne, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5001 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5002 @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	5003 This function is equivalent to @code{x != y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5004 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5005 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5006 BINARY_OP_DEFUN_BODY (op_ne);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5009 DEFUN (times, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5010 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5011 @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	5012 This function is equivalent to @code{x .* y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5013 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5014 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5015 BINARY_OP_DEFUN_BODY (op_el_mul);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5018 DEFUN (rdivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5019 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5020 @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	5021 This function is equivalent to @code{x ./ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5022 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5023 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5024 BINARY_OP_DEFUN_BODY (op_el_div);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5027 DEFUN (power, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5028 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5029 @deftypefn {Built-in Function} {} power (@var{x}, @var{y})\n\
7623 431f3788f5c4 minor doc patch David Bateman <dbateman@free.fr> parents: 7620 diff changeset	5030 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	5031 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5032 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5033 BINARY_OP_DEFUN_BODY (op_el_pow);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5036 DEFUN (ldivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5037 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5038 @deftypefn {Built-in Function} {} ldivide (@var{x}, @var{y})\n\
7623 431f3788f5c4 minor doc patch David Bateman <dbateman@free.fr> parents: 7620 diff changeset	5039 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	5040 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5041 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5042 BINARY_OP_DEFUN_BODY (op_el_ldiv);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5045 DEFUN (and, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5046 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5047 @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	5048 This function is equivalent to @code{x & y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5049 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5050 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5051 BINARY_OP_DEFUN_BODY (op_el_and);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5054 DEFUN (or, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5055 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5056 @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	5057 This function is equivalent to @code{x \| y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5058 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5059 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5060 BINARY_OP_DEFUN_BODY (op_el_or);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5061 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5062
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5063 static double tic_toc_timestamp = -1.0;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5064
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5065 DEFUN (tic, args, nargout,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5066 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5067 @deftypefn {Built-in Function} {} tic ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5068 @deftypefnx {Built-in Function} {} toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5069 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	5070 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	5071 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	5072 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5073 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5074 tic ();\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5075 # many computations later...\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5076 elapsed_time = toc ();\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5077 @end example\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 @noindent\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5080 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	5081 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	5082 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5083 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	5084 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	5085 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5086 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5087 @group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5088 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	5089 @result{} 5\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5090 @end group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5091 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5092 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5093 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	5094 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	5095 recent call to @code{tic}.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5096 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5097 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	5098 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	5099 @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	5100 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	5101 doing nothing at all. For example,\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5102 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5103 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5104 @group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5105 tic (); sleep (5); toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5106 @result{} 5\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5107 t = cputime (); sleep (5); cputime () - t\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5108 @result{} 0\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5109 @end group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5110 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5111 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5112 @noindent\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5113 (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	5114 coarse resolution.)\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5115 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5116 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5117 octave_value retval;
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5118
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5119 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5120
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5121 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5122 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5123
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5124 octave_time now;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5125
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5126 double tmp = now.double_value ();
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5127
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5128 if (nargout > 0)
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5129 retval = static_cast<octave_uint64> (1e6 * tmp);
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5130 else
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5131 tic_toc_timestamp = tmp;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5132
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5133 return retval;
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
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5136 DEFUN (toc, args, nargout,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5137 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5138 @deftypefn {Built-in Function} {} toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5139 See tic.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5140 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5141 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5142 octave_value retval;
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5143
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5144 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5145
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5146 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5147 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5148
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5149 if (tic_toc_timestamp < 0)
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5150 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5151 warning ("toc called before timer set");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5152 if (nargout > 0)
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5153 retval = Matrix ();
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5154 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5155 else
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5156 {
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5157 octave_time now;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5158
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5159 double tmp = now.double_value () - tic_toc_timestamp;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5160
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5161 if (nargout > 0)
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5162 retval = tmp;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5163 else
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5164 octave_stdout << "Elapsed time is " << tmp << " seconds.\n";
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5165 }
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5166
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5167 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5168 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5169
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5170 DEFUN (cputime, args, ,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5171 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5172 @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	5173 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	5174 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	5175 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	5176 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	5177 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	5178 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	5179 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	5180 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	5181 CPU time used is nonzero.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5182 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5183 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5184 octave_value_list retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5185 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5186 double usr = 0.0;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5187 double sys = 0.0;
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 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5190 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5191
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5192 #if defined (HAVE_GETRUSAGE)
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 struct rusage ru;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5195
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5196 getrusage (RUSAGE_SELF, &ru);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5197
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5198 usr = static_cast<double> (ru.ru_utime.tv_sec) +
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5199 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	5200
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5201 sys = static_cast<double> (ru.ru_stime.tv_sec) +
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5202 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	5203
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5204 #elif defined (HAVE_TIMES) && defined (HAVE_SYS_TIMES_H)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5205
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5206 struct tms t;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5207
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5208 times (&t);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5209
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5210 unsigned long ticks;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5211 unsigned long seconds;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5212 unsigned long fraction;
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_utime + t.tms_cutime;
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 usr = 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 ticks = t.tms_stime + t.tms_cstime;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5222 fraction = ticks % HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5223 seconds = ticks / HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5224
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5225 sys = static_cast<double> (seconds) + static_cast<double>(fraction) /
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5226 static_cast<double>(HZ);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5227
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5228 #elif defined (__WIN32__)
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5229
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5230 HANDLE hProcess = GetCurrentProcess ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5231 FILETIME ftCreation, ftExit, ftUser, ftKernel;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5232 GetProcessTimes (hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5233
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5234 int64_t itmp = (reinterpret_cast<int64_t > (&ftUser));
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5235 usr = static_cast<double> (itmp) * 1e-7;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5236
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5237 itmp = (reinterpret_cast<int64_t > (&ftKernel));
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5238 sys = static_cast<double> (itmp) * 1e-7;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5239
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5240 #endif
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5241
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5242 retval (2) = sys;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5243 retval (1) = usr;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5244 retval (0) = sys + usr;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5245
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5246 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5247 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5248
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5249 DEFUN (sort, args, nargout,
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5250 "-- texinfo --\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5251 @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	5252 @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	5253 @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	5254 @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	5255 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	5256 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	5257 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5258 For example,\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5259 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5260 @example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5261 @group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5262 sort ([1, 2; 2, 3; 3, 1])\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5263 @result{} 1 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5264 2 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5265 3 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5266 @end group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5267 @end example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5268 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5269 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	5270 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	5271 matrix. For example,\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5272 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5273 @example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5274 @group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5275 [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	5276 @result{} s = 1 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5277 2 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5278 3 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5279 @result{} i = 1 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5280 2 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5281 3 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5282 @end group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5283 @end example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5284 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5285 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	5286 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	5287 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	5288 @code{mode} are `ascend' or `descend'.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5289 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5290 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	5291 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	5292 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5293 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	5294 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	5295 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5296 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	5297 ordered lists.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5298 @end deftypefn")
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 octave_value_list retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5301
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5302 int nargin = args.length ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5303 sortmode smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5304
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5305 if (nargin < 1 \|\| nargin > 3)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5306 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5307 print_usage ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5308 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5309 }
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 bool return_idx = nargout > 1;
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 octave_value arg = args(0);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5314
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5315 int dim = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5316 if (nargin > 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5317 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5318 if (args(1).is_string ())
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 std::string mode = args(1).string_value();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5321 if (mode == "ascend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5322 smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5323 else if (mode == "descend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5324 smode = DESCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5325 else
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 error ("sort: mode must be either \"ascend\" or \"descend\"");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5328 return retval;
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 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5331 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5332 dim = args(1).nint_value () - 1;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5333 }
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 if (nargin > 2)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5336 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5337 if (args(1).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5338 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5339 print_usage ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5340 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5341 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5342
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5343 if (! args(2).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5344 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5345 error ("sort: mode must be a string");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5346 return retval;
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 std::string mode = args(2).string_value();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5349 if (mode == "ascend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5350 smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5351 else if (mode == "descend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5352 smode = DESCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5353 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5354 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5355 error ("sort: mode must be either \"ascend\" or \"descend\"");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5356 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5357 }
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
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5360 dim_vector dv = arg.dims ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5361 if (error_state)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5362 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5363 gripe_wrong_type_arg ("sort", arg);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5364 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5365 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5366 if (nargin == 1 \|\| args(1).is_string ())
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 // Find first non singleton dimension
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5369 for (int i = 0; i < dv.length (); i++)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5370 if (dv(i) > 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5371 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5372 dim = i;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5373 break;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5374 }
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 else
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 (dim < 0 \|\| dim > dv.length () - 1)
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 error ("sort: dim must be a valid dimension");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5381 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5382 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5383 }
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 if (return_idx)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5386 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5387 Array<octave_idx_type> sidx;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5388
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5389 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	5390 retval (1) = NDArray (sidx, true);
7433 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 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5393 retval(0) = arg.sort (dim, smode);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5394
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5395 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5396 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5397
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5398 /*
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5399
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5400 %% Double
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5401 %!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	5402 %!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	5403 %!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	5404 %!error (sort ([NaN, 1, -1, 2, Inf], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5405 %!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	5406 %!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	5407 %!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	5408 %!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	5409 %!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	5410 %!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	5411 %!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	5412 %!assert (sort (1), 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5413
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5414 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5415 %! [v, i] = sort ([NaN, 1, -1, Inf, 1]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5416 %! assert (v, [-1, 1, 1, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5417 %! assert (i, [3, 2, 5, 4, 1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5418
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5419 %% Complex
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5420 %!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	5421 %!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	5422 %!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	5423 %!error (sort ([NaN, 1i, -1, 2, Inf], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5424 %!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	5425 %!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	5426 %!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	5427 %!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	5428 %!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	5429 %!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	5430 %!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	5431 %!assert (sort (1i), 1i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5432
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5433 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5434 %! [v, i] = sort ([NaN, 1i, -1, Inf, 1, 1i]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5435 %! assert (v, [1, 1i, 1i, -1, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5436 %! assert (i, [5, 2, 6, 3, 4, 1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5437
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5438 %% Single
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])), 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	5440 %!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	5441 %!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	5442 %!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	5443 %!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	5444 %!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	5445 %!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	5446 %!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	5447 %!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	5448 %!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	5449 %!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	5450 %!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	5451
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5452 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5453 %! [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	5454 %! 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	5455 %! 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	5456
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5457 %% Single Complex
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])), 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	5459 %!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	5460 %!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	5461 %!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	5462 %!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	5463 %!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	5464 %!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	5465 %!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	5466 %!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	5467 %!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	5468 %!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	5469 %!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	5470
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5471 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5472 %! [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	5473 %! 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	5474 %! 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	5475
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5476 %% Bool
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5477 %!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	5478 %!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	5479 %!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	5480 %!error (sort ([true, false, true, false], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5481 %!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	5482 %!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	5483 %!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	5484 %!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	5485 %!assert (sort (true), true)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5486
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5487 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5488 %! [v, i] = sort ([true, false, true, false]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5489 %! assert (v, [false, false, true, true])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5490 %! assert (i, [2, 4, 1, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5491
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5492 %% Sparse Double
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])), sparse ([-1, 0, 0, 1, 2, Inf, NaN]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5494 %!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	5495 %!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	5496 %!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	5497 %!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	5498 %!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	5499 %!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	5500 %!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	5501
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5502 %!shared a
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5503 %! a = randn (10, 10);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5504 %! a (a < 0) = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5505 %!assert (sort (sparse (a)), sparse (sort (a)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5506 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5507 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5508 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5509 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5510 %! [vs, is] = sort (sparse (a));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5511 %! assert (vs, sparse (v))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5512 %! assert (is, i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5513
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5514 %% Sparse Complex
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])), sparse ([0, 0, 1i, -1, 2, Inf, NaN]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5516 %!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	5517 %!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	5518 %!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	5519 %!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	5520 %!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	5521 %!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	5522 %!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	5523
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5524 %!shared a
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5525 %! a = randn (10, 10);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5526 %! a (a < 0) = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5527 %! a = 1i * a;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5528 %!assert (sort (sparse (a)), sparse (sort (a)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5529 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5530 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5531 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5532 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5533 %! [vs, is] = sort (sparse (a));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5534 %! assert (vs, sparse (v))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5535 %! assert (is, i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5536
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5537 %% Sparse Bool
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5538 %!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	5539 %!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	5540 %!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	5541 %!error (sort (sparse ([true, false, true, false], 3)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5542 %!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	5543 %!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	5544 %!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	5545 %!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	5546
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5547 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5548 %! [v, i] = sort (sparse([true, false, true, false]));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5549 %! assert (v, sparse([false, false, true, true]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5550 %! assert (i, [2, 4, 1, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5551
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5552 %% Cell string array
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5553 %!shared a, b, c
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5554 %! a = {"Alice", "Cecile", "Eric", "Barry", "David"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5555 %! b = {"Alice", "Barry", "Cecile", "David", "Eric"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5556 %! c = {"Eric", "David", "Cecile", "Barry", "Alice"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5557 %!assert (sort (a), b);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5558 %!assert (sort (a, 1), a)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5559 %!assert (sort (a, 2), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5560 %!error (sort (a, 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5561 %!assert (sort (a, "ascend"), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5562 %!assert (sort (a, 2, "ascend"), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5563 %!assert (sort (a, "descend"), c)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5564 %!assert (sort (a, 2, "descend"), c)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5565
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5566 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5567 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5568 %! assert (i, [1, 4, 2, 5, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5569
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5570 %!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	5571 %!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	5572
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5573 */
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5574
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5575 /*
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5576 ;;; Local Variables: ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5577 ;;; mode: C++ ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5578 ;;; End: ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5579 */

Mercurial > hg > octave-avbm

annotate src/data.cc @ 8129:5d56d4fb6abd