octave-lyh: src/data.cc annotate

annotate src/data.cc @ 8920:eb63fbe60fab

update copyright notices

author	John W. Eaton <jwe@octave.org>
date	Sat, 07 Mar 2009 10:41:27 -0500
parents	7d48766c21a5
children	c2099a4d12ea

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,
8920 eb63fbe60fab update copyright notices John W. Eaton <jwe@octave.org> parents: 8812 diff changeset	4 2003, 2004, 2005, 2006, 2007, 2008 John W. Eaton
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5 Copyright (C) 2009 Jaroslav Hajek
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	6
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	7 This file is part of Octave.
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	8
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	9 Octave is free software; you can redistribute it and/or modify it
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	10 under the terms of the GNU General Public License as published by the
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	11 Free Software Foundation; either version 3 of the License, or (at your
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	12 option) any later version.
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	13
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	14 Octave is distributed in the hope that it will be useful, but WITHOUT
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	17 for more details.
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	18
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	19 You should have received a copy of the GNU General Public License
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	20 along with Octave; see the file COPYING. If not, see
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	21 <http://www.gnu.org/licenses/>.
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	22
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	23 */
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	24
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	25 #ifdef HAVE_CONFIG_H
1192 b6360f2d4fa6 [project @ 1995-03-30 21:38:35 by jwe] jwe parents: 1129 diff changeset	26 #include <config.h>
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	27 #endif
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	28
7078 405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	29 #include "systime.h"
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	30
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	31 #ifdef HAVE_SYS_TYPES_H
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	32 #include <sys/types.h>
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	33 #endif
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	34
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	35 #ifdef HAVE_SYS_RESOURCE_H
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	36 #include <sys/resource.h>
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	37 #endif
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	38
2184 dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	39 #include <cfloat>
dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	40
1728 42b4f904f1af [project @ 1996-01-09 11:36:01 by jwe] jwe parents: 1572 diff changeset	41 #include <string>
42b4f904f1af [project @ 1996-01-09 11:36:01 by jwe] jwe parents: 1572 diff changeset	42
2184 dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	43 #include "lo-ieee.h"
7231 2eb392d058bb [project @ 2007-11-30 18:53:29 by jwe] jwe parents: 7189 diff changeset	44 #include "lo-math.h"
1755 3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe] jwe parents: 1742 diff changeset	45 #include "str-vec.h"
4153 6b96ce9f5743 [project @ 2002-11-06 20:38:49 by jwe] jwe parents: 4114 diff changeset	46 #include "quit.h"
1755 3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe] jwe parents: 1742 diff changeset	47
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	48 #include "Cell.h"
1352 19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	49 #include "defun.h"
19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	50 #include "error.h"
19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	51 #include "gripes.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	52 #include "oct-map.h"
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	53 #include "oct-obj.h"
2366 c90105b99479 [project @ 1996-10-11 23:22:27 by jwe] jwe parents: 2305 diff changeset	54 #include "ov.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	55 #include "ov-float.h"
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	56 #include "ov-complex.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	57 #include "ov-flt-complex.h"
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	58 #include "ov-cx-mat.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	59 #include "ov-flt-cx-mat.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	60 #include "ov-cx-sparse.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	61 #include "parse.h"
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	62 #include "pt-mat.h"
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	63 #include "utils.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	64 #include "variables.h"
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	65 #include "pager.h"
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	66 #include "xnorm.h"
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	67
7914 e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	68 #if ! defined (HAVE_HYPOTF) && defined (HAVE__HYPOTF)
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	69 #define hypotf _hypotf
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	70 #define HAVE_HYPOTF 1
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	71 #endif
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	72
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	73 #define ANY_ALL(FCN) \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	74 \
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	75 octave_value retval; \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	76 \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	77 int nargin = args.length (); \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	78 \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	79 if (nargin == 1 \|\| nargin == 2) \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	80 { \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	81 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	82 \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	83 if (! error_state) \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	84 { \
4556 773a21e4fce8 [project @ 2003-10-28 05:02:10 by jwe] jwe parents: 4554 diff changeset	85 if (dim >= -1) \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	86 retval = args(0).FCN (dim); \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	87 else \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	88 error (#FCN ": invalid dimension argument = %d", dim + 1); \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	89 } \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	90 else \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	91 error (#FCN ": expecting dimension argument to be an integer"); \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	92 } \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	93 else \
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	94 print_usage (); \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	95 \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	96 return retval
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	97
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	98 DEFUN (all, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	99 "-- texinfo --\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	100 @deftypefn {Built-in Function} {} all (@var{x}, @var{dim})\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	101 The function @code{all} behaves like the function @code{any}, except\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	102 that it returns true only if all the elements of a vector, or all the\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	103 elements along dimension @var{dim} of a matrix, are nonzero.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	104 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	105 {
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	106 ANY_ALL (all);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	107 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	108
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	109 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	110
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	111 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	112 %! x = ones (3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	113 %! x(1,1) = 0;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	114 %! assert((all (all (rand (3) + 1) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	115 %! && all (all (x) == [0, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	116 %! && all (x, 1) == [0, 1, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	117 %! && all (x, 2) == [0; 1; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	118
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	119 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	120 %! x = ones (3, 'single');
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	121 %! x(1,1) = 0;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	122 %! assert((all (all (single (rand (3) + 1)) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	123 %! && all (all (x) == [0, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	124 %! && all (x, 1) == [0, 1, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	125 %! && all (x, 2) == [0; 1; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	126
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	127 %!error <Invalid call to all.*> all ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	128 %!error <Invalid call to all.*> all (1, 2, 3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	129
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	130 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	131
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	132 DEFUN (any, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	133 "-- texinfo --\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	134 @deftypefn {Built-in Function} {} any (@var{x}, @var{dim})\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	135 For a vector argument, return 1 if any element of the vector is\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	136 nonzero.\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	137 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	138 For a matrix argument, return a row vector of ones and\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	139 zeros with each element indicating whether any of the elements of the\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	140 corresponding column of the matrix are nonzero. For example,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	141 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	142 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	143 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	144 any (eye (2, 4))\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	145 @result{} [ 1, 1, 0, 0 ]\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	146 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	147 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	148 \n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	149 If the optional argument @var{dim} is supplied, work along dimension\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	150 @var{dim}. For example,\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	151 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	152 @example\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	153 @group\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	154 any (eye (2, 4), 2)\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	155 @result{} [ 1; 1 ]\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	156 @end group\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	157 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	158 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	159 {
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	160 ANY_ALL (any);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	161 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	162
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	163 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	164
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	165 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	166 %! x = zeros (3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	167 %! x(3,3) = 1;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	168 %! assert((all (any (x) == [0, 0, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	169 %! && all (any (ones (3)) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	170 %! && any (x, 1) == [0, 0, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	171 %! && any (x, 2) == [0; 0; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	172
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	173 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	174 %! x = zeros (3,'single');
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	175 %! x(3,3) = 1;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	176 %! assert((all (any (x) == [0, 0, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	177 %! && all (any (ones (3, 'single')) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	178 %! && any (x, 1) == [0, 0, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	179 %! && any (x, 2) == [0; 0; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	180
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	181 %!error <Invalid call to any.*> any ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	182 %!error <Invalid call to any.*> any (1, 2, 3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	183
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	184 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	185
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	186 // These mapping functions may also be useful in other places, eh?
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	187
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	188 typedef double (*d_dd_fcn) (double, double);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	189 typedef float (*f_ff_fcn) (float, float);
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	190
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	191 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	192 map_d_m (d_dd_fcn f, double x, const NDArray& y)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	193 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	194 NDArray retval (y.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	195 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	196
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	197 const double *y_data = y.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	198
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	199 octave_idx_type nel = y.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	200
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	201 for (octave_idx_type i = 0; i < nel; i++)
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	202 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	203 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	204 r_data[i] = f (x, y_data[i]);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	205 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	206
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	207 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	208 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	209
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	210 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	211 map_f_fm (f_ff_fcn f, float x, const FloatNDArray& y)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	212 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	213 FloatNDArray retval (y.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	214 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	215
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	216 const float *y_data = y.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	217
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	218 octave_idx_type nel = y.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	219
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	220 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	221 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	222 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	223 r_data[i] = f (x, y_data[i]);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	224 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	225
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	226 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	227 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	228
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	229 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	230 map_m_d (d_dd_fcn f, const NDArray& x, double y)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	231 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	232 NDArray retval (x.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	233 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	234
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	235 const double *x_data = x.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	236
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	237 octave_idx_type nel = x.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	238
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	239 for (octave_idx_type i = 0; i < nel; i++)
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	240 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	241 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	242 r_data[i] = f (x_data[i], y);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	243 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	244
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	245 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	246 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	247
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	248 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	249 map_fm_f (f_ff_fcn f, const FloatNDArray& x, float y)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	250 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	251 FloatNDArray retval (x.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	252 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	253
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	254 const float *x_data = x.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	255
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	256 octave_idx_type nel = x.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	257
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	258 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	259 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	260 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	261 r_data[i] = f (x_data[i], y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	262 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	263
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	264 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	265 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	266
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	267 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	268 map_m_m (d_dd_fcn f, const NDArray& x, const NDArray& y)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	269 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	270 assert (x.dims () == y.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	271
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	272 NDArray retval (x.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	273 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	274
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	275 const double *x_data = x.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	276 const double *y_data = y.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	277
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	278 octave_idx_type nel = x.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	279
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	280 for (octave_idx_type i = 0; i < nel; i++)
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	281 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	282 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	283 r_data[i] = f (x_data[i], y_data[i]);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	284 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	285
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	286 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	287 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	288
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	289 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	290 map_fm_fm (f_ff_fcn f, const FloatNDArray& x, const FloatNDArray& y)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	291 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	292 assert (x.dims () == y.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	293
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	294 FloatNDArray retval (x.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	295 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	296
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	297 const float *x_data = x.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	298 const float *y_data = y.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	299
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	300 octave_idx_type nel = x.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	301
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	302 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	303 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	304 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	305 r_data[i] = f (x_data[i], y_data[i]);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	306 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	307
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	308 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	309 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	310
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	311 static SparseMatrix
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	312 map_d_s (d_dd_fcn f, double x, const SparseMatrix& y)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	313 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	314 octave_idx_type nr = y.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	315 octave_idx_type nc = y.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	316 SparseMatrix retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	317 double f_zero = f (x, 0.);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	318
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	319 if (f_zero != 0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	320 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	321 retval = SparseMatrix (nr, nc, f_zero);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	322
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	323 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	324 for (octave_idx_type i = y.cidx (j); i < y.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	325 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	326 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	327 retval.data (y.ridx(i) + j * nr) = f (x, y.data (i));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	328 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	329
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	330 retval.maybe_compress (true);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	331 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	332 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	333 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	334 octave_idx_type nz = y.nnz ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	335 retval = SparseMatrix (nr, nc, nz);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	336 octave_idx_type ii = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	337 retval.cidx (ii) = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	338
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	339 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	340 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	341 for (octave_idx_type i = y.cidx (j); i < y.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	342 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	343 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	344 double val = f (x, y.data (i));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	345
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	346 if (val != 0.0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	347 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	348 retval.data (ii) = val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	349 retval.ridx (ii++) = y.ridx (i);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	350 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	351 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	352 retval.cidx (j + 1) = ii;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	353 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	354
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	355 retval.maybe_compress (false);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	356 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	357
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	358 return retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	359 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	360
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	361 static SparseMatrix
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	362 map_s_d (d_dd_fcn f, const SparseMatrix& x, double y)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	363 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	364 octave_idx_type nr = x.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	365 octave_idx_type nc = x.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	366 SparseMatrix retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	367 double f_zero = f (0., y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	368
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	369 if (f_zero != 0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	370 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	371 retval = SparseMatrix (nr, nc, f_zero);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	372
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	373 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	374 for (octave_idx_type i = x.cidx (j); i < x.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	375 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	376 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	377 retval.data (x.ridx(i) + j * nr) = f (x.data (i), y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	378 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	379
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	380 retval.maybe_compress (true);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	381 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	382 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	383 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	384 octave_idx_type nz = x.nnz ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	385 retval = SparseMatrix (nr, nc, nz);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	386 octave_idx_type ii = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	387 retval.cidx (ii) = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	388
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	389 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	390 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	391 for (octave_idx_type i = x.cidx (j); i < x.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	392 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	393 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	394 double val = f (x.data (i), y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	395
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	396 if (val != 0.0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	397 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	398 retval.data (ii) = val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	399 retval.ridx (ii++) = x.ridx (i);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	400 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	401 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	402 retval.cidx (j + 1) = ii;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	403 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	404
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	405 retval.maybe_compress (false);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	406 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	407
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	408 return retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	409 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	410
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	411 static SparseMatrix
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	412 map_s_s (d_dd_fcn f, const SparseMatrix& x, const SparseMatrix& y)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	413 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	414 octave_idx_type nr = x.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	415 octave_idx_type nc = x.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	416
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	417 octave_idx_type y_nr = y.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	418 octave_idx_type y_nc = y.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	419
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	420 assert (nr == y_nr && nc == y_nc);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	421
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	422 SparseMatrix retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	423 double f_zero = f (0., 0.);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	424
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	425 if (f_zero != 0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	426 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	427 retval = SparseMatrix (nr, nc, f_zero);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	428 octave_idx_type k1 = 0, k2 = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	429
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	430 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	431 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	432 while (k1 < x.cidx(j+1) && k2 < y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	433 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	434 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	435 if (k1 >= x.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	436 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	437 retval.data (y.ridx(k2) + j * nr) = f (0.0, y.data (k2));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	438 k2++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	439 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	440 else if (k2 >= y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	441 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	442 retval.data (x.ridx(k1) + j * nr) = f (x.data (k1), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	443 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	444 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	445 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	446 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	447 octave_idx_type rx = x.ridx(k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	448 octave_idx_type ry = y.ridx(k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	449
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	450 if (rx < ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	451 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	452 retval.data (rx + j * nr) = f (x.data (k1), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	453 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	454 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	455 else if (rx > ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	456 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	457 retval.data (ry + j * nr) = f (0.0, y.data (k2));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	458 k2++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	459 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	460 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	461 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	462 retval.data (ry + j * nr) = f (x.data (k1), y.data (k2));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	463 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	464 k2++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	465 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	466 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	467 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	468 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	469
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	470 retval.maybe_compress (true);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	471 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	472 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	473 {
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	474 octave_idx_type nz = x.nnz () + y.nnz ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	475 retval = SparseMatrix (nr, nc, nz);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	476 octave_idx_type ii = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	477 retval.cidx (ii) = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	478 octave_idx_type k1 = 0, k2 = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	479
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	480 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	481 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	482 while (k1 < x.cidx(j+1) && k2 < y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	483 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	484 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	485 double val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	486 octave_idx_type r;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	487 if (k1 >= x.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	488 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	489 r = y.ridx (k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	490 val = f (0.0, y.data (k2++));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	491 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	492 else if (k2 >= y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	493 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	494 r = x.ridx (k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	495 val = f (x.data (k1++), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	496 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	497 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	498 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	499 octave_idx_type rx = x.ridx(k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	500 octave_idx_type ry = y.ridx(k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	501
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	502 if (rx < ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	503 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	504 r = x.ridx (k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	505 val = f (x.data (k1++), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	506 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	507 else if (rx > ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	508 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	509 r = y.ridx (k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	510 val = f (0.0, y.data (k2++));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	511 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	512 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	513 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	514 r = y.ridx (k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	515 val = f (x.data (k1++), y.data (k2++));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	516 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	517 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	518 if (val != 0.0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	519 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	520 retval.data (ii) = val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	521 retval.ridx (ii++) = r;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	522 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	523 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	524 retval.cidx (j + 1) = ii;
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	525 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	526
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	527 retval.maybe_compress (false);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	528 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	529
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	530 return retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	531 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	532
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	533 DEFUN (atan2, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	534 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	535 @deftypefn {Mapping Function} {} atan2 (@var{y}, @var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	536 Compute atan (@var{y} / @var{x}) for corresponding elements of @var{y}\n\
8347 fa78cb8d8a5c corrections for typos Brian Gough<bjg@network-theory.co.uk> parents: 8303 diff changeset	537 and @var{x}. The result is in the range -pi to pi.\n\
3439 3234a698073a [project @ 2000-01-14 09:51:14 by jwe] jwe parents: 3428 diff changeset	538 @end deftypefn")
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	539 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	540 octave_value retval;
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	541
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	542 int nargin = args.length ();
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	543
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	544 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	545 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	546 if (args(0).is_integer_type () \|\| args(1).is_integer_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	547 error ("atan2: not defined for integer types");
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	548 else
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	549 {
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	550 octave_value arg_y = args(0);
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	551 octave_value arg_x = args(1);
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	552
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	553 dim_vector y_dims = arg_y.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	554 dim_vector x_dims = arg_x.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	555
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	556 bool y_is_scalar = y_dims.all_ones ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	557 bool x_is_scalar = x_dims.all_ones ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	558
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	559 bool is_float = arg_y.is_single_type () \|\| arg_x.is_single_type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	560
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	561 if (y_is_scalar && x_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	562 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	563 if (is_float)
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	564 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	565 float y = arg_y.float_value ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	566
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	567 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	568 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	569 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	570
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	571 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	572 retval = atan2f (y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	573 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	574 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	575 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	576 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	577 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	578
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	579 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	580 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	581 double x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	582
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	583 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	584 retval = atan2 (y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	585 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	586 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	587 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	588 else if (y_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	589 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	590 if (is_float)
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	591 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	592 float y = arg_y.float_value ();
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	593
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	594 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	595 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	596 // Even if x is sparse return a full matrix here
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	597 FloatNDArray x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	598
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	599 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	600 retval = map_f_fm (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	601 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	602 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	603 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	604 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	605 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	606
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	607 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	608 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	609 // Even if x is sparse return a full matrix here
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	610 NDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	611
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	612 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	613 retval = map_d_m (atan2, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	614 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	615 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	616 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	617 else if (x_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	618 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	619 if (arg_y.is_sparse_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	620 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	621 SparseMatrix y = arg_y.sparse_matrix_value ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	622
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	623 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	624 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	625 double x = arg_x.double_value ();
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	626
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	627 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	628 retval = map_s_d (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	629 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	630 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	631 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	632 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	633 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	634
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	635 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	636 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	637 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	638
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	639 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	640 retval = map_fm_f (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	641 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	642 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	643 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	644 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	645 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	646
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	647 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	648 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	649 double x = arg_x.double_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	650
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	651 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	652 retval = map_m_d (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	653 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	654 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	655 }
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	656 else if (y_dims == x_dims)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	657 {
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	658 // Even if y is sparse return a full matrix here
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	659 if (arg_x.is_sparse_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	660 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	661 SparseMatrix y = arg_y.sparse_matrix_value ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	662
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	663 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	664 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	665 SparseMatrix x = arg_x.sparse_matrix_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	666
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	667 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	668 retval = map_s_s (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	669 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	670 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	671 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	672 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	673 FloatNDArray y = arg_y.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	674
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	675 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	676 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	677 FloatNDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	678
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	679 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	680 retval = map_fm_fm (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	681 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	682 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	683 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	684 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	685 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	686
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	687 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	688 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	689 NDArray x = arg_x.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	690
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	691 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	692 retval = map_m_m (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	693 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	694 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	695 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	696 else
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	697 error ("atan2: nonconformant matrices");
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	698 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	699 }
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	700 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	701 print_usage ();
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	702
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	703 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	704 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	705
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	706 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	707 %!assert (size (atan2 (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	708 %!assert (size (atan2 (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	709 %!assert (size (atan2 (rand (2, 3, 4), 1)), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	710 %!assert (size (atan2 (1, rand (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	711 %!assert (size (atan2 (1, 2)), [1, 1])
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	712
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	713 %!test
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	714 %! rt2 = sqrt (2);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	715 %! rt3 = sqrt (3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	716 %! v = [0, pi/6, pi/4, pi/3, -pi/3, -pi/4, -pi/6, 0];
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	717 %! y = [0, rt3, 1, rt3, -rt3, -1, -rt3, 0];
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	718 %! x = [1, 3, 1, 1, 1, 1, 3, 1];
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	719 %! assert(atan2 (y, x), v, sqrt (eps));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	720
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	721 %!test
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	722 %! rt2 = sqrt (2);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	723 %! rt3 = sqrt (3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	724 %! v = single([0, pi/6, pi/4, pi/3, -pi/3, -pi/4, -pi/6, 0]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	725 %! y = single([0, rt3, 1, rt3, -rt3, -1, -rt3, 0]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	726 %! x = single([1, 3, 1, 1, 1, 1, 3, 1]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	727 %! assert(atan2 (y, x), v, sqrt (eps('single')));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	728
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	729 %!error <Invalid call to atan2.*> atan2 ();
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	730 %!error <Invalid call to atan2.*> atan2 (1, 2, 3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	731
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	732 */
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	733
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	734
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	735
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	736 DEFUN (hypot, args, ,
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	737 "-- texinfo --\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	738 @deftypefn {Mapping Function} {} hypot (@var{x}, @var{y})\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	739 Compute square-root of the squares of @var{x} and @var{y}\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	740 element-by-element. This equivalent to @code{sqrt (@var{x}.^ 2 + @var{y}\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	741 .^ 2)}, but calculated in a manner that avoids overflows for large\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	742 values of @var{x} or @var{y}.\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	743 @end deftypefn")
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	744 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	745 octave_value retval;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	746
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	747 int nargin = args.length ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	748
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	749 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	750 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	751 if (args(0).is_integer_type () \|\| args(1).is_integer_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	752 error ("hypot: not defined for integer types");
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	753 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	754 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	755 octave_value arg_x = args(0);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	756 octave_value arg_y = args(1);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	757
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	758 dim_vector x_dims = arg_x.dims ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	759 dim_vector y_dims = arg_y.dims ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	760
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	761 bool x_is_scalar = x_dims.all_ones ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	762 bool y_is_scalar = y_dims.all_ones ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	763
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	764 bool is_float = arg_y.is_single_type () \|\| arg_x.is_single_type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	765
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	766 if (y_is_scalar && x_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	767 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	768 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	769 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	770 float x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	771 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	772 x = abs (arg_x.float_complex_value ());
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	773 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	774 x = arg_x.float_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	775
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	776 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	777 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	778 float y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	779 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	780 y = abs (arg_y.float_complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	781 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	782 y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	783
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	784 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	785 retval = hypotf (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	786 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	787 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	788 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	789 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	790 double x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	791 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	792 x = abs (arg_x.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	793 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	794 x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	795
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	796 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	797 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	798 double y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	799 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	800 y = abs (arg_y.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	801 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	802 y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	803
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	804 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	805 retval = hypot (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	806 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	807 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	808 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	809 else if (y_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	810 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	811 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	812 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	813 FloatNDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	814 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	815 x = arg_x.float_complex_array_value ().abs ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	816 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	817 x = arg_x.float_array_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	818
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	819 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	820 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	821 float y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	822 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	823 y = abs (arg_y.float_complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	824 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	825 y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	826
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	827 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	828 retval = map_fm_f (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	829 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	830 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	831 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	832 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	833 NDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	834 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	835 x = arg_x.complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	836 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	837 x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	838
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	839 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	840 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	841 double y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	842 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	843 y = abs (arg_y.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	844 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	845 y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	846
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	847 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	848 retval = map_m_d (hypot, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	849 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	850 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	851 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	852 else if (x_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	853 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	854 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	855 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	856 float x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	857 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	858 x = abs (arg_x.float_complex_value ());
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	859 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	860 x = arg_x.float_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	861
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	862 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	863 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	864 FloatNDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	865 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	866 y = arg_y.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	867 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	868 y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	869
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	870 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	871 retval = map_f_fm (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	872 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	873 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	874 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	875 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	876 double x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	877 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	878 x = abs (arg_x.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	879 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	880 x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	881
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	882 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	883 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	884 NDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	885 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	886 y = arg_y.complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	887 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	888 y = arg_y.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	889
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	890 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	891 retval = map_d_m (hypot, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	892 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	893 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	894 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	895 else if (y_dims == x_dims)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	896 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	897 if (arg_x.is_sparse_type () && arg_y.is_sparse_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	898 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	899 SparseMatrix x;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	900 if (arg_x.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	901 x = arg_x.sparse_complex_matrix_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	902 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	903 x = arg_x.sparse_matrix_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	904
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	905 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	906 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	907 SparseMatrix y;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	908 if (arg_y.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	909 y = arg_y.sparse_complex_matrix_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	910 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	911 y = arg_y.sparse_matrix_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	912
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	913 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	914 retval = map_s_s (hypot, x, y);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	915 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	916 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	917 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	918 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	919 FloatNDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	920 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	921 x = arg_x.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	922 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	923 x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	924
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	925 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	926 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	927 FloatNDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	928 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	929 y = arg_y.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	930 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	931 y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	932
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	933 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	934 retval = map_fm_fm (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	935 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	936 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	937 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	938 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	939 NDArray x;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	940 if (arg_x.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	941 x = arg_x.complex_array_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	942 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	943 x = arg_x.array_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	944
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	945 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	946 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	947 NDArray y;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	948 if (arg_y.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	949 y = arg_y.complex_array_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	950 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	951 y = arg_y.array_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	952
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	953 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	954 retval = map_m_m (hypot, x, y);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	955 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	956 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	957 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	958 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	959 error ("hypot: nonconformant matrices");
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	960 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	961 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	962 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	963 print_usage ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	964
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	965 return retval;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	966 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	967
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	968 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	969 %!assert (size (hypot (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	970 %!assert (size (hypot (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	971 %!assert (size (hypot (rand (2, 3, 4), 1)), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	972 %!assert (size (hypot (1, rand (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	973 %!assert (size (hypot (1, 2)), [1, 1])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	974 %!assert (hypot (1:10, 1:10), sqrt(2) * [1:10], 16*eps)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	975 %!assert (hypot (single(1:10), single(1:10)), single(sqrt(2) * [1:10]));
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	976 */
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	977
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	978 template<typename T, typename ET>
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	979 void
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	980 map_2_xlog2 (const Array<T>& x, Array<T>& f, Array<ET>& e)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	981 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	982 f = Array<T>(x.dims ());
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	983 e = Array<ET>(x.dims ());
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	984 for (octave_idx_type i = 0; i < x.numel (); i++)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	985 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	986 int exp;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	987 f.xelem (i) = xlog2 (x(i), exp);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	988 e.xelem (i) = exp;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	989 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	990 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	991
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	992 DEFUN (log2, args, nargout,
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	993 "-- texinfo --\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	994 @deftypefn {Mapping Function} {} log2 (@var{x})\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	995 @deftypefnx {Mapping Function} {[@var{f}, @var{e}] = } log2 (@var{x})\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	996 Compute the base-2 logarithm for each element of @var{x}.\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	997 If called with two output arguments, split @var{x} to\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	998 binary mantissa and exponent so that @code{1/2 <= abs(f) < 1} and\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	999 @var{e} is an integer. If @code{x = 0}, @code{f = e = 0}.\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1000 @seealso{log, log10, log2, exp}\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1001 @end deftypefn")
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1002 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1003 octave_value_list retval;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1004
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1005 if (args.length () == 1)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1006 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1007 if (nargout < 2)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1008 retval(0) = args(0).log2 ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1009 else if (args(0).is_single_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1010 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1011 if (args(0).is_real_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1012 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1013 FloatNDArray f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1014 FloatNDArray x = args(0).float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1015 // FIXME -- should E be an int value?
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1016 FloatMatrix e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1017 map_2_xlog2 (x, f, e);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1018 retval (1) = e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1019 retval (0) = f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1020 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1021 else if (args(0).is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1022 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1023 FloatComplexNDArray f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1024 FloatComplexNDArray x = args(0).float_complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1025 // FIXME -- should E be an int value?
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1026 FloatNDArray e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1027 map_2_xlog2 (x, f, e);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1028 retval (1) = e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1029 retval (0) = f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1030 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1031 }
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1032 else if (args(0).is_real_type ())
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1033 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1034 NDArray f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1035 NDArray x = args(0).array_value ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1036 // FIXME -- should E be an int value?
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1037 Matrix e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1038 map_2_xlog2 (x, f, e);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1039 retval (1) = e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1040 retval (0) = f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1041 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1042 else if (args(0).is_complex_type ())
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1043 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1044 ComplexNDArray f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1045 ComplexNDArray x = args(0).complex_array_value ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1046 // FIXME -- should E be an int value?
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1047 NDArray e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1048 map_2_xlog2 (x, f, e);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1049 retval (1) = e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1050 retval (0) = f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1051 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1052 else
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1053 gripe_wrong_type_arg ("log2", args(0));
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1054 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1055 else
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1056 print_usage ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1057
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1058 return retval;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1059 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1060
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1061 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1062 %!assert(log2 ([1/4, 1/2, 1, 2, 4]), [-2, -1, 0, 1, 2]);
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1063 %!assert(log2(Inf), Inf);
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1064 %!assert(isnan(log2(NaN)));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1065 %!assert(log2(4i), 2 + log2(1i));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1066 %!assert(log2(complex(0,Inf)), Inf + log2(i));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1067
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1068 %!test
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1069 %! [f, e] = log2 ([0,-1; 2,-4; Inf,-Inf]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1070 %! assert (f, [0,-0.5; 0.5,-0.5; Inf,-Inf]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1071 %! assert (e, [0,1;2,3;0,0])
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1072
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1073 %!test
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1074 %! [f, e] = log2 (complex (zeros (3, 2), [0,-1; 2,-4; Inf,-Inf]));
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1075 %! assert (f, complex (zeros (3, 2), [0,-0.5; 0.5,-0.5; Inf,-Inf]));
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1076 %! assert (e, [0,1; 2,3; 0,0]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1077 */
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1078
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1079 DEFUN (fmod, args, ,
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1080 "-- texinfo --\n\
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1081 @deftypefn {Mapping Function} {} fmod (@var{x}, @var{y})\n\
4685 14a1c9f42f67 [project @ 2004-01-06 17:20:02 by jwe] jwe parents: 4593 diff changeset	1082 Compute the floating point remainder of dividing @var{x} by @var{y}\n\
14a1c9f42f67 [project @ 2004-01-06 17:20:02 by jwe] jwe parents: 4593 diff changeset	1083 using the C library function @code{fmod}. The result has the same\n\
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1084 sign as @var{x}. If @var{y} is zero, the result is implementation-defined.\n\
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1085 @end deftypefn")
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1086 {
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1087 octave_value retval;
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1088
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1089 int nargin = args.length ();
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1090
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1091 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1092 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1093 octave_value arg_y = args(0);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1094 octave_value arg_x = args(1);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1095
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1096 dim_vector y_dims = arg_y.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1097 dim_vector x_dims = arg_x.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1098
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1099 bool y_is_scalar = y_dims.all_ones ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1100 bool x_is_scalar = x_dims.all_ones ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1101
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1102 bool is_float = arg_y.is_single_type () \|\| arg_x.is_single_type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1103
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1104 if (y_is_scalar && x_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1105 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1106 if (is_float)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1107 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1108 float y = arg_y.float_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1109
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1110 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1111 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1112 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1113
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1114 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1115 retval = fmod (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1116 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1117 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1118 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1119 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1120 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1121
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1122 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1123 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1124 double x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1125
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1126 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1127 retval = fmod (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1128 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1129 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1130 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1131 else if (y_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1132 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1133 if (is_float)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1134 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1135 float y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1136
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1137 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1138 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1139 FloatNDArray x = arg_x.float_array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1140
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1141 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1142 retval = map_fm_f (fmodf, x, y);
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1143 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1144 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1145 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1146 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1147 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1148
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1149 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1150 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1151 if (arg_x.is_sparse_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1152 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1153 SparseMatrix x = arg_x.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1154
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1155 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1156 retval = map_s_d (fmod, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1157 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1158 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1159 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1160 NDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1161
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1162 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1163 retval = map_m_d (fmod, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1164 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1165 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1166 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1167 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1168 else if (x_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1169 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1170 if (arg_y.is_sparse_type ())
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1171 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1172 SparseMatrix y = arg_y.sparse_matrix_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1173
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1174 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1175 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1176 double x = arg_x.double_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1177
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1178 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1179 retval = map_d_s (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1180 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1181 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1182 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1183 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1184 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1185
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1186 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1187 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1188 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1189
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1190 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1191 retval = map_f_fm (fmodf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1192 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1193 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1194 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1195 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1196 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1197
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1198 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1199 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1200 double x = arg_x.double_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1201
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1202 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1203 retval = map_d_m (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1204 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1205 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1206 }
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1207 else if (y_dims == x_dims)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1208 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1209 if (arg_y.is_sparse_type () \|\| arg_x.is_sparse_type ())
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1210 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1211 SparseMatrix y = arg_y.sparse_matrix_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1212
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1213 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1214 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1215 SparseMatrix x = arg_x.sparse_matrix_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1216
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1217 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1218 retval = map_s_s (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1219 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1220 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1221 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1222 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1223 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1224
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1225 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1226 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1227 FloatNDArray x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1228
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1229 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1230 retval = map_fm_fm (fmodf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1231 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1232 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1233 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1234 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1235 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1236
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1237 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1238 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1239 NDArray x = arg_x.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1240
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1241 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1242 retval = map_m_m (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1243 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1244 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1245 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1246 else
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1247 error ("fmod: nonconformant matrices");
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1248 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1249 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1250 print_usage ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1251
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1252 return retval;
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1253 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1254
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1255 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1256 %!assert (size (fmod (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1257 %!assert (size (fmod (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4])
7743 fbe27e477578 more tests fixed John W. Eaton <jwe@octave.org> parents: 7741 diff changeset	1258 %!assert (size (fmod (rand (2, 3, 4), 1)), [2, 3, 4])
fbe27e477578 more tests fixed John W. Eaton <jwe@octave.org> parents: 7741 diff changeset	1259 %!assert (size (fmod (1, rand (2, 3, 4))), [2, 3, 4])
fbe27e477578 more tests fixed John W. Eaton <jwe@octave.org> parents: 7741 diff changeset	1260 %!assert (size (fmod (1, 2)), [1, 1])
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1261 */
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1262
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1263 // FIXME Need to convert the reduction functions of this file for single precision
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1264
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1265 #define NATIVE_REDUCTION_1(FCN, TYPE, DIM) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1266 (arg.is_ ## TYPE ## _type ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1267 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1268 TYPE ## NDArray tmp = arg. TYPE ##_array_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1269 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1270 if (! error_state) \
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1271 { \
ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1272 octave_ ## TYPE::clear_conv_flags (); \
ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1273 retval = tmp.FCN (DIM); \
ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1274 if (octave_ ## TYPE::get_trunc_flag ()) \
ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1275 { \
ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1276 gripe_native_integer_math_truncated (#FCN, \
ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1277 octave_ ## TYPE::type_name ()); \
ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1278 octave_ ## TYPE::clear_conv_flags (); \
ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1279 } \
ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1280 } \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1281 }
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1282
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1283 #define NATIVE_REDUCTION(FCN, BOOL_FCN) \
7112 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 octave_value retval; \
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 int nargin = args.length (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1288 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1289 bool isnative = false; \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1290 bool isdouble = false; \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1291 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1292 if (nargin > 1 && args(nargin - 1).is_string ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1293 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1294 std::string str = args(nargin - 1).string_value (); \
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 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1297 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1298 if (str == "native") \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1299 isnative = true; \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1300 else if (str == "double") \
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1301 isdouble = true; \
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1302 else \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1303 error ("sum: unrecognized string argument"); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1304 nargin --; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1305 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1306 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1307 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1308 if (nargin == 1 \|\| nargin == 2) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1309 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1310 octave_value arg = args(0); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1311 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1312 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	1313 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1314 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1315 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1316 if (dim >= -1) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1317 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1318 if (arg.is_sparse_type ()) \
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 (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1321 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1322 SparseMatrix tmp = arg.sparse_matrix_value (); \
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 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1325 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1326 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1327 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1328 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1329 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	1330 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1331 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1332 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1333 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1334 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1335 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1336 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1337 if (isnative) \
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 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	1340 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	1341 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	1342 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	1343 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	1344 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	1345 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	1346 else if NATIVE_REDUCTION_1 (FCN, int64, dim) \
8756 d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	1347 else if (arg.is_bool_type ()) \
d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	1348 { \
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1349 boolNDArray tmp = arg.bool_array_value (); \
8756 d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	1350 if (! error_state) \
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1351 retval = boolNDArray (tmp.BOOL_FCN (dim)); \
8756 d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	1352 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1353 else if (arg.is_char_matrix ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1354 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1355 error (#FCN, ": invalid char type"); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1356 } \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1357 else if (!isdouble && arg.is_single_type ()) \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1358 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1359 if (arg.is_complex_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1360 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1361 FloatComplexNDArray tmp = \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1362 arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1363 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1364 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1365 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1366 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1367 else if (arg.is_real_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1368 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1369 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1370 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1371 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1372 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1373 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1374 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1375 else if (arg.is_complex_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1376 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1377 ComplexNDArray tmp = arg.complex_array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1378 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1379 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1380 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1381 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1382 else if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1383 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1384 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1385 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1386 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1387 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1388 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1389 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1390 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1391 gripe_wrong_type_arg (#FCN, arg); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1392 return retval; \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1393 } \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1394 } \
8756 d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	1395 else if (arg.is_bool_type ()) \
d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	1396 { \
d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	1397 boolNDArray tmp = arg.bool_array_value (); \
d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	1398 if (! error_state) \
d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	1399 retval = tmp.FCN (dim); \
d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8734 diff changeset	1400 } \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1401 else if (!isdouble && arg.is_single_type ()) \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1402 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1403 if (arg.is_real_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1404 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1405 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1406 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1407 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1408 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1409 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1410 else if (arg.is_complex_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1411 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1412 FloatComplexNDArray tmp = \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1413 arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1414 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1415 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1416 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1417 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1418 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1419 else if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1420 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1421 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1422 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1423 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1424 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1425 } \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1426 else if (arg.is_complex_type ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1427 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1428 ComplexNDArray tmp = arg.complex_array_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1429 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1430 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1431 retval = tmp.FCN (dim); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1432 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1433 else \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1434 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1435 gripe_wrong_type_arg (#FCN, arg); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1436 return retval; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1437 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1438 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1439 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1440 else \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1441 error (#FCN ": invalid dimension argument = %d", dim + 1); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1442 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1443 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1444 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1445 else \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1446 print_usage (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1447 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1448 return retval
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1449
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1450 #define DATA_REDUCTION(FCN) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1451 \
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	1452 octave_value retval; \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1453 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1454 int nargin = args.length (); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1455 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1456 if (nargin == 1 \|\| nargin == 2) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1457 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1458 octave_value arg = args(0); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1459 \
3864 e78705239df5 [project @ 2001-11-16 12:56:20 by jwe] jwe parents: 3797 diff changeset	1460 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	1461 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1462 if (! error_state) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1463 { \
4556 773a21e4fce8 [project @ 2003-10-28 05:02:10 by jwe] jwe parents: 4554 diff changeset	1464 if (dim >= -1) \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1465 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1466 if (arg.is_real_type ()) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1467 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1468 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1469 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1470 SparseMatrix tmp = arg.sparse_matrix_value (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1471 \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1472 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1473 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1474 } \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1475 else if (arg.is_single_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1476 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1477 FloatNDArray tmp = arg.float_array_value (); \
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 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1480 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1481 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1482 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1483 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1484 NDArray tmp = arg.array_value (); \
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 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1487 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1488 } \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1489 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1490 else if (arg.is_complex_type ()) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1491 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1492 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1493 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1494 SparseComplexMatrix tmp = arg.sparse_complex_matrix_value (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1495 \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1496 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1497 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1498 } \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1499 else if (arg.is_single_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1500 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1501 FloatComplexNDArray tmp = arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1502 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1503 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1504 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1505 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1506 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1507 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1508 ComplexNDArray tmp = arg.complex_array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1509 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1510 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1511 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1512 } \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1513 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1514 else \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1515 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1516 gripe_wrong_type_arg (#FCN, arg); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1517 return retval; \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1518 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1519 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1520 else \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1521 error (#FCN ": invalid dimension argument = %d", dim + 1); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1522 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1523 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1524 else \
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1525 print_usage (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1526 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1527 return retval
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1528
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1529 DEFUN (cumprod, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1530 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1531 @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	1532 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	1533 @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	1534 products).\n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1535 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1536 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	1537 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	1538 same orientation as @var{x}.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1539 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1540 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1541 DATA_REDUCTION (cumprod);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1542 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1543
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1544 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1545
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1546 %!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	1547 %!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	1548 %!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	1549 %!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	1550
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1551 %!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	1552 %!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	1553 %!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	1554 %!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	1555
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1556 %!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	1557
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1558 %!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	1559 %!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	1560
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1561 %!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	1562 %!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	1563
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
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1566 DEFUN (cumsum, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1567 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1568 @deftypefn {Built-in Function} {} cumsum (@var{x}, @var{dim})\n\
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1569 @deftypefnx {Built-in Function} {} cumsum (@dots{}, 'native')\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1570 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	1571 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	1572 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1573 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	1574 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	1575 same orientation as @var{x}.\n\
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1576 \n\
ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1577 The \"native\" argument implies the summation is performed in native type,\n\
ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1578 analogously to @code{sum}.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1579 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1580 {
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	1581 NATIVE_REDUCTION (cumsum, cumsum);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1582 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1583
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1584 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1585
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1586 %!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	1587 %!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	1588 %!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	1589 %!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	1590
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1591 %!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	1592 %!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	1593 %!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	1594 %!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	1595
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1596 %!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	1597
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1598 %!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	1599 %!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	1600
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1601 %!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	1602 %!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	1603
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1604 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1605
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1606 DEFUN (diag, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1607 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1608 @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	1609 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	1610 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	1611 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	1612 @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	1613 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	1614 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1615 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1616 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1617 diag ([1, 2, 3], 1)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1618 @result{} 0 1 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1619 0 0 2 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1620 0 0 0 3\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1621 0 0 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1622 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1623 @end example\n\
6772 315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1624 \n\
315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1625 @noindent\n\
315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1626 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	1627 @var{k}-th diagonal of the matrix.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1628 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1629 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	1630 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1631
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1632 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1633
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	1634 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	1635 retval = args(0).diag();
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	1636 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	1637 {
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1638 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	1639
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1640 if (error_state)
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1641 error ("diag: invalid second argument");
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1642 else
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1643 retval = args(0).diag(k);
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1644 }
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1645 else if (nargin == 3)
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1646 {
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1647 octave_value arg0 = args(0);
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1648 if (arg0.ndims () == 2 && (args(0).rows () == 1 \|\| args(0).columns () == 1))
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1649 {
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1650 octave_idx_type m = args(1).int_value (), n = args(2).int_value ();
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1651 if (! error_state)
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1652 retval = arg0.diag ().resize (dim_vector (m, n));
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1653 else
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1654 error ("diag: invalid dimensions");
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1655 }
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1656 else
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1657 error ("diag: first argument must be a vector");
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	1658 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1659 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1660 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1661
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1662 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1663 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1664
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1665 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1666
8459 d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1667 %!assert(full (diag ([1; 2; 3])), [1, 0, 0; 0, 2, 0; 0, 0, 3]);
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1668 %!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	1669 %!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	1670 %!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	1671 %!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	1672
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1673 %!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	1674 %!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	1675 %!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	1676
8459 d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1677 %!assert(full (diag (single([1; 2; 3]))), single([1, 0, 0; 0, 2, 0; 0, 0, 3]));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1678 %!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	1679 %!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	1680 %!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	1681 %!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	1682
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1683 %!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	1684 %!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	1685 %!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	1686
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1687 %!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	1688 %!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	1689 %!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	1690 %!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	1691 %!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	1692
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1693 %!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	1694 %!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	1695 %!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	1696
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1697 %!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	1698
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1699 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1700
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1701 DEFUN (prod, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1702 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1703 @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	1704 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	1705 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	1706 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1707 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	1708 return the product of the elements.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1709 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1710 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1711 DATA_REDUCTION (prod);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1712 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1713
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1714 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1715
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1716 %!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	1717 %!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	1718 %!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	1719 %!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	1720
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1721 %!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	1722 %!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	1723 %!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	1724 %!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	1725
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1726 %!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	1727
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1728 %!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	1729 %!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	1730 %!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	1731 %!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	1732 %!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	1733 %!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	1734 %!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	1735 %!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	1736 %!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	1737 %!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	1738 %!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	1739 %!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	1740 %!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	1741 %!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	1742
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1743 %!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	1744 %!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	1745 %!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	1746 %!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	1747 %!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	1748 %!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	1749 %!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	1750 %!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	1751 %!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	1752 %!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	1753 %!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	1754 %!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	1755 %!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	1756 %!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	1757
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1758 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1759
8107 8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1760 #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	1761 do \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1762 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1763 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	1764 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	1765 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1766 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	1767 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1768 OCTAVE_QUIT; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1769 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1770 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	1771 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1772 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	1773 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1774 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	1775 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1776 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	1777 return retval; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1778 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1779 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	1780 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1781 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	1782 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1783 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	1784 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	1785 break; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1786 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1787 else \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1788 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	1789 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1790 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1791 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1792 while (0)
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1793
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1794 #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	1795 do \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1796 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1797 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	1798 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1799 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	1800 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1801 retval = result; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1802 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1803 while (0)
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1804
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1805 static octave_value
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1806 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	1807 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1808 octave_value retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1809
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1810 int n_args = args.length ();
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1811
5714 24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1812 if (n_args == 1)
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1813 retval = Matrix ();
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1814 else if (n_args == 2)
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1815 retval = args(1);
5507 273612001e3a [project @ 2005-10-26 08:01:24 by dbateman] dbateman parents: 5476 diff changeset	1816 else if (n_args > 2)
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1817 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1818 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	1819
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1820 if (error_state)
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1821 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1822 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	1823 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1824 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1825
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1826 if (dim >= 0)
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1827 {
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1828
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1829 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	1830 std::string result_type = args(1).class_name ();
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1831
8107 8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1832 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	1833 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	1834 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	1835 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	1836
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1837 for (int i = 2; i < args.length (); i++)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1838 {
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1839 // 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	1840 // dimensions of the final array after concatenation.
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1841
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1842 if (! dv.concat (args(i).dims (), dim))
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1843 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1844 // Dimensions do not match.
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1845 error ("cat: dimension mismatch");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1846 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1847 }
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1848
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1849 result_type =
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1850 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	1851
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1852 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	1853 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	1854 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	1855 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	1856 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	1857 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	1858 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	1859 any_sparse_p = true;
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1860 }
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 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 (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	1863 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1864 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	1865 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1866 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	1867 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	1868 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1869 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	1870 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1871 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1872 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1873 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	1874 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	1875 else
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 (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	1877 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1878 }
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 == "single")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1880 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1881 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	1882 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	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 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	1885 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	1886 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1887 else if (result_type == "char")
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1888 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1889 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	1890
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1891 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	1892
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1893 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	1894
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1895 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	1896
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1897 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	1898 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1899 else if (result_type == "logical")
5533 667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1900 {
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1901 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	1902 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	1903 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1904 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	1905 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1906 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	1907 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	1908 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	1909 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	1910 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	1911 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	1912 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	1913 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	1914 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	1915 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	1916 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	1917 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	1918 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	1919 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	1920 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	1921 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	1922 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1923 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1924 // 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	1925 // 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	1926 // 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	1927 // 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	1928 // 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	1929 // 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	1930 // 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	1931 //
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1932 // 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	1933 // 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	1934 // (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	1935 // 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	1936 // 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	1937
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1938 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	1939 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	1940
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1941 if (error_state)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1942 return retval;
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1943
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1944 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	1945 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	1946
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1947 for (int j = 1; j < n_args; j++)
6401 f8cbc0871ed6 [project @ 2007-03-09 15:34:45 by dbateman] dbateman parents: 6399 diff changeset	1948 {
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1949 // 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	1950 // 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	1951 // 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	1952 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	1953
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1954 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	1955 return retval;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1956
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1957 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	1958
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1959 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	1960 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1961 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	1962 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	1963 break;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1964 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1965 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1966 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	1967 dv_tmp (dim) : 1);
6401 f8cbc0871ed6 [project @ 2007-03-09 15:34:45 by dbateman] dbateman parents: 6399 diff changeset	1968 }
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1969 retval = tmp;
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1970 }
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1971
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1972 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	1973 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1974 // 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	1975 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	1976 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	1977 }
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1978 }
5533 667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1979 else
667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1980 error ("%s: invalid dimension argument", fname.c_str ());
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1981 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1982 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1983 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	1984
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1985 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1986 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1987
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1988 DEFUN (horzcat, args, ,
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1989 "-- texinfo --\n\
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1990 @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	1991 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	1992 @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	1993 @seealso{cat, vertcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	1994 @end deftypefn")
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1995 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1996 octave_value_list args_tmp = args;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1997
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1998 int dim = 2;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1999
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2000 octave_value d (dim);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2001
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2002 args_tmp.prepend (d);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2003
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	2004 return do_cat (args_tmp, "horzcat");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2005 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2006
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2007 DEFUN (vertcat, args, ,
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2008 "-- texinfo --\n\
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2009 @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	2010 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	2011 @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	2012 @seealso{cat, horzcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2013 @end deftypefn")
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2014 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2015 octave_value_list args_tmp = args;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2016
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2017 int dim = 1;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2018
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2019 octave_value d (dim);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2020
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2021 args_tmp.prepend (d);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2022
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	2023 return do_cat (args_tmp, "vertcat");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2024 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	2025
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2026 DEFUN (cat, args, ,
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2027 "-- texinfo --\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2028 @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	2029 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	2030 @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	2031 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2032 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2033 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2034 A = ones (2, 2);\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2035 B = zeros (2, 2);\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2036 cat (2, A, B)\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2037 @result{} ans =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2038 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2039 1 1 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2040 1 1 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2041 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2042 @end example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2043 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2044 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	2045 second dimension the following way:\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2046 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2047 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2048 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2049 [A, B].\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2050 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2051 @end example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2052 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2053 @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	2054 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	2055 following example shows:\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2056 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2057 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2058 cat (4, ones(2, 2), zeros (2, 2))\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2059 @result{} ans =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2060 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2061 ans(:,:,1,1) =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2062 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2063 1 1\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2064 1 1\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2065 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2066 ans(:,:,1,2) =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2067 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2068 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2069 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2070 @end example\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2071 @seealso{horzcat, vertcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2072 @end deftypefn")
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2073 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	2074 return do_cat (args, "cat");
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2075 }
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2076
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2077 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2078
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2079 %!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	2080 %! 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	2081 %!
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, 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	2083 %! 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	2084 %! 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	2085 %! 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	2086 %! 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	2087 %! 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	2088 %! 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	2089 %! 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	2090 %!
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, 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	2092 %! 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	2093 %! 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	2094 %! 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	2095 %! 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	2096 %! 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	2097 %! 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	2098 %! 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	2099 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2100 %! 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	2101 %! 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	2102 %! 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	2103 %! 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	2104 %! 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	2105 %! 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	2106 %! 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	2107 %! 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	2108 %! 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	2109 %!
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, 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	2111 %! 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	2112 %! 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	2113 %! 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	2114 %! 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	2115 %! 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	2116 %! 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	2117 %! 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	2118 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2119 %! assert (cat (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	2120 %! 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	2121 %! 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	2122 %! 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	2123 %! 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	2124 %! 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	2125 %! 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	2126 %! 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	2127 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2128 %! assert ([cast(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	2129 %! 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	2130 %! 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	2131 %! 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	2132 %! 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	2133 %! 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	2134 %! 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	2135 %! 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	2136 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2137 %! assert (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	2138 %! 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	2139 %! 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	2140 %! 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	2141 %! 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	2142 %! 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	2143 %! 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	2144 %! 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	2145 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2146 %! 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	2147 %! 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	2148 %! 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	2149 %! 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	2150 %! 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	2151 %! 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	2152 %! 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	2153 %! 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	2154 %! endif
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2155 %! ret = true;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2156
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('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	2158 %!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	2159 %!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	2160 %!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	2161
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('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	2163 %!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	2164 %!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	2165 %!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	2166 %!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	2167 %!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	2168 %!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	2169 %!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	2170 %!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	2171 %!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	2172 %!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	2173 %!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	2174 %!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	2175 %!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	2176 %!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	2177 %!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	2178 %!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	2179 %!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	2180 %!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	2181 %!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	2182
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2183 %!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	2184 %!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	2185 %!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	2186 %!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	2187 %!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	2188 %!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	2189 %!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	2190 %!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	2191 %!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	2192 %!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	2193 %!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	2194 %!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	2195 %!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	2196 %!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	2197 %!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	2198 %!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	2199 %!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	2200 %!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	2201 %!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	2202 %!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	2203
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2204 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2205
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2206 static octave_value
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2207 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	2208 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2209 octave_value retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2210
5148 9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2211 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	2212 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2213 Array<int> vec = args(1).int_vector_value ();
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2214
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	2215 // 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	2216 // here and pass that to permute?
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2217
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2218 int n = vec.length ();
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2219
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2220 for (int i = 0; i < n; i++)
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2221 vec(i)--;
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2222
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2223 octave_value ret = args(0).permute (vec, inv);
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2224
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2225 if (! error_state)
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2226 retval = ret;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2227 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2228 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2229 print_usage ();
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2230
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2231 return retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2232 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2233
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2234 DEFUN (permute, args, ,
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2235 "-- texinfo --\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2236 @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	2237 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	2238 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	2239 @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	2240 @seealso{ipermute}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2241 @end deftypefn")
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2242 {
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2243 return do_permute (args, false);
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2244 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2245
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2246 DEFUN (ipermute, args, ,
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2247 "-- texinfo --\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2248 @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	2249 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	2250 \n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2251 @example\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2252 ipermute (permute (a, perm), perm)\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2253 @end example\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2254 returns the original array @var{a}.\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2255 @seealso{permute}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2256 @end deftypefn")
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2257 {
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2258 return do_permute (args, true);
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2259 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2260
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2261 DEFUN (length, args, ,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2262 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2263 @deftypefn {Built-in Function} {} length (@var{a})\n\
4176 b8ec44432831 [project @ 2002-11-13 02:49:14 by jwe] jwe parents: 4153 diff changeset	2264 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	2265 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	2266 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	2267 @end deftypefn")
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2268 {
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2269 octave_value retval;
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2270
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2271 if (args.length () == 1)
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2272 {
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2273 int len = args(0).length ();
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2274
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2275 if (! error_state)
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	2276 retval = len;
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2277 }
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2278 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2279 print_usage ();
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2280
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2281 return retval;
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2282 }
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2283
4554 78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2284 DEFUN (ndims, args, ,
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2285 "-- texinfo --\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2286 @deftypefn {Built-in Function} {} ndims (@var{a})\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2287 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	2288 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	2289 Trailing singleton dimensions are not counted.\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2290 @end deftypefn")
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2291 {
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2292 octave_value retval;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2293
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2294 if (args.length () == 1)
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2295 {
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2296 int n_dims = args(0).ndims ();
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2297
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2298 if (! error_state)
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2299 retval = n_dims;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2300 }
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2301 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2302 print_usage ();
4554 78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2303
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2304 return retval;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2305 }
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2306
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2307 DEFUN (numel, args, ,
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2308 "-- texinfo --\n\
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2309 @deftypefn {Built-in Function} {} numel (@var{a})\n\
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2310 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	2311 @seealso{size}\n\
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2312 @end deftypefn")
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2313 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2314 octave_value retval;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2315
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2316 if (args.length () == 1)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2317 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2318 int numel = args(0).numel ();
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2319
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2320 if (! error_state)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2321 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2322 if (numel < 0)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2323 numel = 0;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2324
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2325 retval = numel;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2326 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2327 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2328 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2329 print_usage ();
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2330
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2331 return retval;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2332 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2333
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2334 DEFUN (size, args, nargout,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2335 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2336 @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	2337 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	2338 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2339 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	2340 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	2341 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	2342 etc. For example,\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2343 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2344 @example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2345 @group\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2346 size ([1, 2; 3, 4; 5, 6])\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2347 @result{} [ 3, 2 ]\n\
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2348 \n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2349 [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	2350 @result{} nr = 3\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2351 @result{} nc = 2\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2352 @end group\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2353 @end example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2354 \n\
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2355 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	2356 corresponding dimension. For example\n\
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2357 \n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2358 @example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2359 size ([1, 2; 3, 4; 5, 6], 2)\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2360 @result{} 2\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2361 @end example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2362 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2363 @noindent\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2364 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	2365 @seealso{numel}\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2366 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2367 {
2086 bfb775fb6fe8 [project @ 1996-04-25 05:55:19 by jwe] jwe parents: 1996 diff changeset	2368 octave_value_list retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2369
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2370 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2371
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2372 if (nargin == 1)
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2373 {
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2374 dim_vector dimensions = args(0).dims ();
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2375
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2376 int ndims = dimensions.length ();
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2377
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2378 Matrix m (1, ndims);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2379
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2380 if (nargout > 1)
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2381 {
5991 265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2382 for (int i = nargout-1; i >= ndims; i--)
265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2383 retval(i) = 1;
265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2384
6197 c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2385 if (ndims > nargout)
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2386 {
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2387 octave_idx_type d = 1;
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2388
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2389 while (ndims >= nargout)
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2390 d *= dimensions(--ndims);
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2391
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2392 retval(ndims) = d;
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2393 }
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2394
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2395 while (ndims--)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2396 retval(ndims) = dimensions(ndims);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2397 }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2398 else
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2399 {
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2400 for (int i = 0; i < ndims; i++)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2401 m(0, i) = dimensions(i);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2402
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2403 retval(0) = m;
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2404 }
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2405 }
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2406 else if (nargin == 2 && nargout < 2)
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2407 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	2408 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	2409
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2410 if (error_state)
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2411 error ("size: expecting scalar as second argument");
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2412 else
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2413 {
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2414 dim_vector dv = args(0).dims ();
e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2415
4911 14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2416 if (nd > 0)
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2417 {
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2418 if (nd <= dv.length ())
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2419 retval(0) = dv(nd-1);
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2420 else
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2421 retval(0) = 1;
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2422 }
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2423 else
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2424 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	2425 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2426 }
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2427 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2428 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2429
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2430 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2431 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2432
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2433 DEFUN (size_equal, args, ,
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2434 "-- texinfo --\n\
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2435 @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	2436 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	2437 Trailing singleton dimensions are ignored.\n\
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2438 @seealso{size, numel}\n\
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2439 @end deftypefn")
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2440 {
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2441 octave_value retval;
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2442
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2443 int nargin = args.length ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2444
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2445 if (nargin >= 2)
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2446 {
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2447 retval = true;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2448
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2449 dim_vector a_dims = args(0).dims ();
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2450 a_dims.chop_trailing_singletons ();
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2451
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2452 for (int i = 1; i < nargin; ++i)
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2453 {
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2454 dim_vector b_dims = args(i).dims ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2455 b_dims.chop_trailing_singletons ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2456
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2457 if (a_dims != b_dims)
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2458 {
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2459 retval = false;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2460 break;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2461 }
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2462 }
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2463 }
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2464 else
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2465 print_usage ();
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2466
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2467 return retval;
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2468 }
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2469
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2470 DEFUN (nnz, args, ,
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2471 "-- texinfo --\n\
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2472 @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	2473 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	2474 @seealso{sparse}\n\
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2475 @end deftypefn")
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2476 {
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2477 octave_value retval;
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2478
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2479 if (args.length () == 1)
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2480 retval = args(0).nnz ();
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2481 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2482 print_usage ();
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2483
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2484 return retval;
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2485 }
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2486
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2487 DEFUN (nzmax, args, ,
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2488 "-- texinfo --\n\
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2489 @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	2490 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	2491 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	2492 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	2493 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	2494 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	2495 @seealso{sparse, spalloc}\n\
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2496 @end deftypefn")
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2497 {
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2498 octave_value retval;
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2499
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2500 if (args.length() == 1)
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2501 retval = args(0).nzmax ();
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2502 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2503 print_usage ();
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2504
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2505 return retval;
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2506 }
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2507
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2508 DEFUN (rows, args, ,
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2509 "-- texinfo --\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2510 @deftypefn {Built-in Function} {} rows (@var{a})\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2511 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	2512 @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	2513 @end deftypefn")
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2514 {
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2515 octave_value retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2516
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2517 if (args.length () == 1)
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2518 retval = args(0).rows ();
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2519 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2520 print_usage ();
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2521
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2522 return retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2523 }
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2524
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2525 DEFUN (columns, args, ,
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2526 "-- texinfo --\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2527 @deftypefn {Built-in Function} {} columns (@var{a})\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2528 Return the number of columns of @var{a}.\n\
8286 6f2d95255911 fix @seealso references to point to existing anchors Thorsten Meyer <thorsten.meyier@gmx.de> parents: 8129 diff changeset	2529 @seealso{size, numel, rows, length, isscalar, isvector, ismatrix}\n\
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2530 @end deftypefn")
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2531 {
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2532 octave_value retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2533
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2534 if (args.length () == 1)
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2535 retval = args(0).columns ();
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2536 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2537 print_usage ();
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2538
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2539 return retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2540 }
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2541
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2542 DEFUN (sum, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2543 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2544 @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	2545 @deftypefnx {Built-in Function} {} sum (@dots{}, 'native')\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2546 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	2547 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	2548 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2549 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	2550 return the sum of the elements.\n\
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2551 \n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2552 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	2553 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	2554 double type. For example\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2555 \n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2556 @example\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2557 sum ([true, true])\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2558 @result{} 2\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2559 sum ([true, true], 'native')\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2560 @result{} true\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2561 @end example\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2562 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2563 {
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	2564 NATIVE_REDUCTION (sum, any);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2565 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2566
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2567 /*
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2568
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2569 %!assert (sum([true,true]), 2)
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2570 %!assert (sum([true,true],'native'), true)
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2571 %!assert (sum(int8([127,10,-20])), 117);
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2572 %!assert (sum(int8([127,10,-20]),'native'), int8(107));
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2573
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2574 %!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	2575 %!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	2576 %!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	2577 %!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	2578
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2579 %!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	2580 %!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	2581 %!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	2582 %!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	2583
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2584 %!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	2585
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2586 %!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	2587 %!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	2588 %!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	2589 %!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	2590 %!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	2591 %!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	2592 %!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	2593 %!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	2594 %!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	2595 %!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	2596 %!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	2597 %!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	2598 %!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	2599 %!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	2600 %!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	2601 %!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	2602 %!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	2603 %!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	2604 %!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	2605
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2606 %!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	2607 %!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	2608 %!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	2609 %!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	2610 %!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	2611 %!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	2612 %!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	2613 %!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	2614 %!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	2615 %!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	2616 %!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	2617 %!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	2618 %!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	2619 %!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	2620 %!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	2621 %!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	2622 %!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	2623 %!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	2624 %!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	2625
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2626 */
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2627
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2628 DEFUN (sumsq, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2629 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2630 @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	2631 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	2632 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	2633 \n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2634 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	2635 return the sum of squares of the elements.\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2636 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2637 This function is conceptually equivalent to computing\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2638 @example\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2639 sum (x .* conj (x), dim)\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2640 @end example\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2641 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	2642 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2643 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2644 DATA_REDUCTION (sumsq);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2645 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2646
7815 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
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2649 %!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	2650 %!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	2651 %!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	2652
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2653 %!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	2654 %!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	2655 %!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	2656
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2657 %!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	2658
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2659 %!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	2660 %!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	2661
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2662 %!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	2663 %!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	2664
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2665 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2666
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2667 DEFUN (islogical, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2668 "-- texinfo --\n\
7144 30c0533e39ae [project @ 2007-11-09 17:37:24 by jwe] jwe parents: 7112 diff changeset	2669 @deftypefn {Built-in Function} {} islogical (@var{x})\n\
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2670 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	2671 @end deftypefn")
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2672 {
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2673 octave_value retval;
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2674
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2675 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2676 retval = args(0).is_bool_type ();
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2677 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2678 print_usage ();
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2679
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2680 return retval;
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2681 }
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2682
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2683 DEFALIAS (isbool, islogical);
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2684
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2685 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2686
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2687 %!assert (islogical(true), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2688 %!assert (islogical(false), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2689 %!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	2690 %!assert (islogical(1), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2691 %!assert (islogical(1i), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2692 %!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	2693 %!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	2694 %!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	2695 %!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	2696
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2697 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2698
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2699 DEFUN (isinteger, args, ,
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2700 "-- texinfo --\n\
6230 06bee64edc08 [project @ 2007-01-08 16:59:35 by jwe] jwe parents: 6223 diff changeset	2701 @deftypefn {Built-in Function} {} isinteger (@var{x})\n\
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2702 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	2703 Note that @code{isinteger (14)} is false because numeric constants in\n\
8429 f34ab2b433e8 One word missing from int8 help string. Francesco PotortÃ¬ <pot@gnu.org> parents: 8366 diff changeset	2704 Octave are double precision floating point values.\n\
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2705 @seealso{isreal, isnumeric, class, isa}\n\
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2706 @end deftypefn")
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2707 {
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2708 octave_value retval;
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2709
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2710 if (args.length () == 1)
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2711 retval = args(0).is_integer_type ();
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2712 else
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2713 print_usage ();
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2714
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2715 return retval;
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2716 }
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2717
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	2718 DEFUN (iscomplex, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2719 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	2720 @deftypefn {Built-in Function} {} iscomplex (@var{x})\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2721 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	2722 @end deftypefn")
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2723 {
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2724 octave_value retval;
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2725
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2726 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2727 retval = args(0).is_complex_type ();
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2728 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2729 print_usage ();
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2730
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2731 return retval;
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2732 }
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2733
7576 7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2734 DEFUN (isfloat, args, ,
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2735 "-- texinfo --\n\
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2736 @deftypefn {Built-in Function} {} isfloat (@var{x})\n\
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2737 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	2738 @end deftypefn")
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2739 {
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2740 octave_value retval;
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2741
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2742 if (args.length () == 1)
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2743 retval = args(0).is_float_type ();
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2744 else
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2745 print_usage ();
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2746
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2747 return retval;
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2748 }
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2749
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	2750 // FIXME -- perhaps this should be implemented with an
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2751 // octave_value member function?
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2752
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2753 DEFUN (complex, args, ,
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2754 "-- texinfo --\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2755 @deftypefn {Built-in Function} {} complex (@var{val})\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2756 @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	2757 Convert @var{x} to a complex value.\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2758 @end deftypefn")
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2759 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2760 octave_value retval;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2761
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2762 int nargin = args.length ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2763
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2764 if (nargin == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2765 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2766 octave_value arg = args(0);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2767
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2768 if (arg.is_complex_type ())
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2769 retval = arg;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2770 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2771 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2772 if (arg.is_sparse_type ())
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2773 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2774 SparseComplexMatrix val = arg.sparse_complex_matrix_value ();
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2775
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2776 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2777 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	2778 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2779 else if (arg.is_single_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2780 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2781 if (arg.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2782 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2783 FloatComplex val = arg.float_complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2784
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2785 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2786 retval = octave_value (new octave_float_complex (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2787 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2788 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2789 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2790 FloatComplexNDArray val = arg.float_complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2791
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2792 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2793 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	2794 }
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2795 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2796 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2797 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2798 if (arg.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2799 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2800 Complex val = arg.complex_value ();
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 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2803 retval = octave_value (new octave_complex (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2804 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2805 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2806 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2807 ComplexNDArray val = arg.complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2808
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2809 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2810 retval = octave_value (new octave_complex_matrix (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2811 }
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2812 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2813
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2814 if (error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2815 error ("complex: invalid conversion");
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2816 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2817 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2818 else if (nargin == 2)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2819 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2820 octave_value re = args(0);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2821 octave_value im = args(1);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2822
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2823 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	2824 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2825 const SparseMatrix re_val = re.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2826 const SparseMatrix im_val = im.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2827
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2828 if (!error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2829 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2830 if (re.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2831 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2832 SparseComplexMatrix result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2833 if (re_val.nnz () == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2834 result = Complex(0, 1) * SparseComplexMatrix (im_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2835 else
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 result = SparseComplexMatrix (im_val.dims (), re_val (0));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2838 octave_idx_type nr = im_val.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2839 octave_idx_type nc = im_val.cols ();
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 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	2842 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2843 octave_idx_type off = j * nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2844 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	2845 i < im_val.cidx(j + 1); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2846 result.data (im_val.ridx(i) + off) =
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2847 result.data (im_val.ridx(i) + off) +
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2848 Complex (0, im_val.data (i));
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 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2851 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	2852 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2853 else if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2854 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2855 SparseComplexMatrix result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2856 if (im_val.nnz () == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2857 result = SparseComplexMatrix (re_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2858 else
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 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	2861 octave_idx_type nr = re_val.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2862 octave_idx_type nc = re_val.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2863
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2864 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	2865 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2866 octave_idx_type off = j * nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2867 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	2868 i < re_val.cidx(j + 1); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2869 result.data (re_val.ridx(i) + off) =
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2870 result.data (re_val.ridx(i) + off) +
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2871 re_val.data (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2872 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2873 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2874 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	2875 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2876 else
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 if (re_val.dims () == im_val.dims ())
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 SparseComplexMatrix result = SparseComplexMatrix(re_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2881 + Complex(0, 1) * SparseComplexMatrix (im_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2882 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	2883 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2884 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2885 error ("complex: dimension mismatch");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2886 }
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 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2889 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	2890 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2891 if (re.numel () == 1)
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 float re_val = re.float_value ();
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 if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2896 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2897 float im_val = im.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2898
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2899 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2900 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	2901 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2902 else
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 const FloatNDArray im_val = im.float_array_value ();
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 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2907 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2908 FloatComplexNDArray result (im_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2909
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2910 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	2911 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	2912
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2913 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	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
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2918 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2919 const FloatNDArray re_val = re.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2920
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2921 if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2922 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2923 float im_val = im.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2924
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2925 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2926 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2927 FloatComplexNDArray result (re_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2928
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2929 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	2930 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	2931
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2932 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	2933 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2934 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2935 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2936 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2937 const FloatNDArray im_val = im.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2938
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2939 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2940 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2941 if (re_val.dims () == im_val.dims ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2942 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2943 FloatComplexNDArray result (re_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2944
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2945 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	2946 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	2947
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2948 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	2949 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2950 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2951 error ("complex: dimension mismatch");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2952 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2953 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2954 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2955 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2956 else if (re.numel () == 1)
5476 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 double re_val = re.double_value ();
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 if (im.numel () == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2961 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2962 double im_val = im.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2963
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2964 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2965 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	2966 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2967 else
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 const NDArray im_val = im.array_value ();
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 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2972 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2973 ComplexNDArray result (im_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2974
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2975 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	2976 result.xelem (i) = Complex (re_val, im_val(i));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2977
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2978 retval = octave_value (new octave_complex_matrix (result));
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 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2983 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2984 const NDArray re_val = re.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2985
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2986 if (im.numel () == 1)
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 double im_val = im.double_value ();
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 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2991 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2992 ComplexNDArray result (re_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2993
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2994 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	2995 result.xelem (i) = Complex (re_val(i), im_val);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2996
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2997 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2998 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2999 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3000 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3001 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3002 const NDArray im_val = im.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3003
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3004 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3005 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3006 if (re_val.dims () == im_val.dims ())
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3007 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3008 ComplexNDArray result (re_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3009
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3010 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	3011 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	3012
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3013 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3014 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3015 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3016 error ("complex: dimension mismatch");
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3017 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3018 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3019 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3020
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3021 if (error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3022 error ("complex: invalid conversion");
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3023 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3024 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3025 print_usage ();
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3026
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3027 return retval;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3028 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	3029
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3030 DEFUN (isreal, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3031 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3032 @deftypefn {Built-in Function} {} isreal (@var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3033 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	3034 @end deftypefn")
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3035 {
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3036 octave_value retval;
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3037
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3038 if (args.length () == 1)
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3039 retval = args(0).is_real_type ();
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3040 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3041 print_usage ();
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3042
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3043 return retval;
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3044 }
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3045
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3046 DEFUN (isempty, args, ,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3047 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3048 @deftypefn {Built-in Function} {} isempty (@var{a})\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3049 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	3050 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	3051 @end deftypefn")
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3052 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3053 octave_value retval = false;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3054
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3055 if (args.length () == 1)
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	3056 retval = args(0).is_empty ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3057 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3058 print_usage ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3059
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3060 return retval;
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3061 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3062
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3063 DEFUN (isnumeric, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3064 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3065 @deftypefn {Built-in Function} {} isnumeric (@var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3066 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	3067 @end deftypefn")
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3068 {
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3069 octave_value retval;
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3070
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3071 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3072 retval = args(0).is_numeric_type ();
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3073 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3074 print_usage ();
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3075
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3076 return retval;
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3077 }
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3078
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3079 DEFUN (islist, args, ,
3526 cc21933776a1 [project @ 2000-02-02 10:53:27 by jwe] jwe parents: 3523 diff changeset	3080 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3081 @deftypefn {Built-in Function} {} islist (@var{x})\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3082 Return nonzero if @var{x} is a list.\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3083 @end deftypefn")
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3084 {
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3085 octave_value retval;
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3086
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3087 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3088 retval = args(0).is_list ();
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3089 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3090 print_usage ();
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3091
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3092 return retval;
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3093 }
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3094
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3095 DEFUN (ismatrix, args, ,
3321 6923abb04e16 [project @ 1999-10-26 18:15:30 by jwe] jwe parents: 3307 diff changeset	3096 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3097 @deftypefn {Built-in Function} {} ismatrix (@var{a})\n\
3321 6923abb04e16 [project @ 1999-10-26 18:15:30 by jwe] jwe parents: 3307 diff changeset	3098 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	3099 @end deftypefn")
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3100 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3101 octave_value retval = false;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3102
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3103 if (args.length () == 1)
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3104 {
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3105 octave_value arg = args(0);
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3106
3212 bf61c443a366 [project @ 1998-11-05 04:24:45 by jwe] jwe parents: 3209 diff changeset	3107 if (arg.is_scalar_type () \|\| arg.is_range ())
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3108 retval = true;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3109 else if (arg.is_matrix_type ())
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3110 retval = (arg.rows () >= 1 && arg.columns () >= 1);
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3111 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3112 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3113 print_usage ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3114
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3115 return retval;
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3116 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3117
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3118 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3119
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3120 %!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	3121 %!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	3122 %!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	3123
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3124 %% 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	3125 %!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	3126
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3127 %!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	3128 %!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	3129 %!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	3130
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3131 %% 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	3132 %!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	3133
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3134 %!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	3135 %!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	3136 %!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	3137
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3138 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3139 %! 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	3140 %! 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	3141
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3142 %!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	3143 %!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	3144
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3145 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3146
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3147 static octave_value
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3148 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	3149 {
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3150 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3151
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3152 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3153
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3154 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	3155
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3156 dim_vector dims (1, 1);
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3157
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3158 if (nargin > 0 && args(nargin-1).is_string ())
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3159 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3160 std::string nm = args(nargin-1).string_value ();
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3161 nargin--;
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3162
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3163 dt = oct_data_conv::string_to_data_type (nm);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3164
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3165 if (error_state)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3166 return retval;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3167 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3168
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3169 switch (nargin)
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3170 {
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	3171 case 0:
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	3172 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3173
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	3174 case 1:
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3175 get_dimensions (args(0), fcn, dims);
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	3176 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3177
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3178 default:
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3179 {
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3180 dims.resize (nargin);
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3181
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3182 for (int i = 0; i < nargin; i++)
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3183 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3184 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	3185
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3186 if (error_state)
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3187 {
4732 b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	3188 error ("%s: expecting scalar integer arguments", fcn);
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3189 break;
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3190 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3191 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3192 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3193 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3194 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3195
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3196 if (! error_state)
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3197 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3198 dims.chop_trailing_singletons ();
4565 1db951a4fcd5 [project @ 2003-10-29 13:49:30 by jwe] jwe parents: 4563 diff changeset	3199
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3200 check_dimensions (dims, fcn);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3201
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	3202 // FIXME -- perhaps this should be made extensible by
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3203 // 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	3204 // the new value.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3205
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3206 // Note that automatic narrowing will handle conversion from
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3207 // NDArray to scalar.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3208
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3209 if (! error_state)
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3210 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3211 switch (dt)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3212 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3213 case oct_data_conv::dt_int8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3214 retval = int8NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3215 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3216
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3217 case oct_data_conv::dt_uint8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3218 retval = uint8NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3219 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3220
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3221 case oct_data_conv::dt_int16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3222 retval = int16NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3223 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3224
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3225 case oct_data_conv::dt_uint16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3226 retval = uint16NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3227 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3228
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3229 case oct_data_conv::dt_int32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3230 retval = int32NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3231 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3232
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3233 case oct_data_conv::dt_uint32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3234 retval = uint32NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3235 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3236
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3237 case oct_data_conv::dt_int64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3238 retval = int64NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3239 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3240
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3241 case oct_data_conv::dt_uint64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3242 retval = uint64NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3243 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3244
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3245 case oct_data_conv::dt_single:
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3246 retval = FloatNDArray (dims, val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3247 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3248
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3249 case oct_data_conv::dt_double:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3250 retval = NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3251 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3252
4986 fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3253 case oct_data_conv::dt_logical:
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3254 retval = boolNDArray (dims, val);
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3255 break;
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3256
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3257 default:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3258 error ("%s: invalid class name", fcn);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3259 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3260 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3261 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3262 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3263
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3264 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3265 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3266
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3267 static octave_value
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3268 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	3269 const char *fcn)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3270 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3271 octave_value retval;
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 int nargin = args.length ();
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 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	3276
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3277 dim_vector dims (1, 1);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3278
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3279 if (nargin > 0 && args(nargin-1).is_string ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3280 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3281 std::string nm = args(nargin-1).string_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3282 nargin--;
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 dt = oct_data_conv::string_to_data_type (nm);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3285
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3286 if (error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3287 return retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3288 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3289
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3290 switch (nargin)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3291 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3292 case 0:
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 1:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3296 get_dimensions (args(0), fcn, dims);
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 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3301 dims.resize (nargin);
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 for (int i = 0; i < nargin; i++)
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 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	3306
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3307 if (error_state)
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 error ("%s: expecting scalar integer arguments", fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3310 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3311 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3312 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3313 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3314 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3315 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3316
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3317 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3318 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3319 dims.chop_trailing_singletons ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3320
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3321 check_dimensions (dims, fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3322
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3323 // Note that automatic narrowing will handle conversion from
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3324 // NDArray to scalar.
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3325
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3326 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3327 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3328 switch (dt)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3329 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3330 case oct_data_conv::dt_single:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3331 retval = FloatNDArray (dims, fval);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3332 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3333
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3334 case oct_data_conv::dt_double:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3335 retval = NDArray (dims, val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3336 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3337
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3338 default:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3339 error ("%s: invalid class name", fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3340 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3341 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3342 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3343 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3344
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3345 return retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3346 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3347
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3348 static octave_value
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3349 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	3350 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3351 octave_value retval;
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 int nargin = args.length ();
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 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	3356
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3357 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3358
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3359 if (nargin > 0 && args(nargin-1).is_string ())
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3360 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3361 std::string nm = args(nargin-1).string_value ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3362 nargin--;
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 dt = oct_data_conv::string_to_data_type (nm);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3365
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3366 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3367 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3368 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3369
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3370 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3371 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3372 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3373 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3374
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3375 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3376 get_dimensions (args(0), fcn, dims);
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 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3381 dims.resize (nargin);
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 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3384 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3385 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	3386
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3387 if (error_state)
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 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3390 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3391 }
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 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3394 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3395 }
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 if (! error_state)
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 dims.chop_trailing_singletons ();
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 check_dimensions (dims, fcn);
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 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3404 // NDArray to scalar.
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 if (! error_state)
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 switch (dt)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3409 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3410 case oct_data_conv::dt_single:
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3411 retval = FloatNDArray (dims, static_cast <float> (val));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3412 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3413
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3414 case oct_data_conv::dt_double:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3415 retval = NDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3416 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3417
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3418 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3419 error ("%s: invalid class name", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3420 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3421 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3422 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3423 }
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 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3426 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3427
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3428 static octave_value
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3429 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	3430 const char *fcn)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3431 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3432 octave_value retval;
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 int nargin = args.length ();
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 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	3437
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3438 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3439
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3440 if (nargin > 0 && args(nargin-1).is_string ())
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3441 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3442 std::string nm = args(nargin-1).string_value ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3443 nargin--;
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 dt = oct_data_conv::string_to_data_type (nm);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3446
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3447 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3448 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3449 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3450
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3451 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3452 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3453 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3454 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3455
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3456 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3457 get_dimensions (args(0), fcn, dims);
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 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3462 dims.resize (nargin);
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 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3465 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3466 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	3467
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3468 if (error_state)
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 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3471 break;
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 }
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 break;
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
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3478 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3479 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3480 dims.chop_trailing_singletons ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3481
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3482 check_dimensions (dims, fcn);
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 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3485 // NDArray to scalar.
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3486
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3487 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3488 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3489 switch (dt)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3490 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3491 case oct_data_conv::dt_single:
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3492 retval = FloatComplexNDArray (dims, static_cast<FloatComplex> (val));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3493 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3494
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3495 case oct_data_conv::dt_double:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3496 retval = ComplexNDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3497 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3498
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3499 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3500 error ("%s: invalid class name", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3501 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3502 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3503 }
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 return retval;
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
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3509 static octave_value
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3510 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	3511 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3512 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3513
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3514 int nargin = args.length ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3515
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3516 dim_vector dims (1, 1);
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 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3519 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3520 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3521 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3522
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3523 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3524 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3525 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3526
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3527 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3528 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3529 dims.resize (nargin);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3530
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3531 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3532 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3533 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	3534
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3535 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3536 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3537 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3538 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3539 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3540 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3541 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3542 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3543 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3544
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3545 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3546 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3547 dims.chop_trailing_singletons ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3548
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3549 check_dimensions (dims, fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3550
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3551 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3552 // NDArray to scalar.
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3553
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3554 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3555 retval = boolNDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3556 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3557
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3558 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3559 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3560
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3561 DEFUN (ones, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3562 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3563 @deftypefn {Built-in Function} {} ones (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3564 @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	3565 @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	3566 @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	3567 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	3568 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	3569 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3570 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	3571 use an expression like\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3572 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3573 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3574 val_matrix = val * ones (n, m)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3575 @end example\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{ones} 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 = ones (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, 1, "ones");
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3586 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: 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(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	3591 %!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	3592 %!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	3593 %!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	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(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	3596 %!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	3597 %!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	3598 %!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	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(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	3601 %!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	3602 %!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	3603 %!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	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
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3607 DEFUN (zeros, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3608 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3609 @deftypefn {Built-in Function} {} zeros (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3610 @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	3611 @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	3612 @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	3613 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	3614 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	3615 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3616 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	3617 the specified type, for example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3618 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3619 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3620 val = zeros (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3621 @end example\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3622 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3623 {
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3624 return fill_matrix (args, 0, "zeros");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3625 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3626
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3627 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3628
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3629 %!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	3630 %!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	3631 %!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	3632 %!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	3633
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3634 %!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	3635 %!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	3636 %!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	3637 %!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	3638
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3639 %!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	3640 %!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	3641 %!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	3642 %!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	3643
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3644 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3645
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3646 DEFUN (Inf, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3647 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3648 @deftypefn {Built-in Function} {} Inf (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3649 @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	3650 @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	3651 @deftypefnx {Built-in Function} {} Inf (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3652 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	3653 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	3654 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	3655 @samp{\"double\"}. The default is @samp{\"double\"}.\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3656 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3657 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3658 return fill_matrix (args, lo_ieee_inf_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3659 lo_ieee_float_inf_value (), "Inf");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3660 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3661
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3662 DEFALIAS (inf, Inf);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3663
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3664 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3665
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3666 %!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	3667 %!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	3668 %!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	3669 %!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	3670
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3671 %!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	3672 %!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	3673 %!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	3674 %!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	3675
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3676 %!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	3677 %!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	3678 %!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	3679 %!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	3680
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3681 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3682
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3683 DEFUN (NaN, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3684 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3685 @deftypefn {Built-in Function} {} NaN (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3686 @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	3687 @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	3688 @deftypefnx {Built-in Function} {} NaN (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3689 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	3690 (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	3691 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3692 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3693 $0/0$, or $\\infty - \\infty$,\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3694 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3695 @end iftex\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3696 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3697 0/0, or @samp{Inf - Inf},\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3698 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3699 or any operation with a NaN.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3700 \n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3701 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	3702 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	3703 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	3704 \n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3705 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	3706 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	3707 @samp{\"double\"}. The default is @samp{\"double\"}.\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3708 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3709 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3710 return fill_matrix (args, lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3711 lo_ieee_float_nan_value (), "NaN");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3712 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3713
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3714 DEFALIAS (nan, NaN);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3715
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3716 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3717 %!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	3718 %!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	3719 %!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	3720 %!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	3721
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3722 %!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	3723 %!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	3724 %!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	3725 %!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	3726
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3727 %!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	3728 %!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	3729 %!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	3730 %!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	3731
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3732 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3733
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3734 DEFUN (e, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3735 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3736 @deftypefn {Built-in Function} {} e (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3737 @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	3738 @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	3739 @deftypefnx {Built-in Function} {} e (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3740 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	3741 to the base of natural logarithms. The constant\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3742 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3743 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3744 $e$\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3745 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3746 @end iftex\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3747 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3748 @var{e}\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3749 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3750 satisfies the equation\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3751 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3752 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3753 $\\log (e) = 1$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3754 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3755 @end iftex\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3756 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3757 @code{log} (@var{e}) = 1.\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3758 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3759 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3760 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3761 #if defined (M_E)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3762 double e_val = M_E;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3763 #else
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3764 double e_val = exp (1.0);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3765 #endif
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3766
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3767 return fill_matrix (args, e_val, "e");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3768 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3769
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3770 DEFUN (eps, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3771 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3772 @deftypefn {Built-in Function} {} eps (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3773 @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	3774 @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	3775 @deftypefnx {Built-in Function} {} eps (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3776 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	3777 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	3778 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	3779 floating point system. This number is obviously system-dependent. On\n\
8487 5701c2fe3327 [docs] 64 bit => 64-bit Brian Gough <bjg@gnu.org> parents: 8459 diff changeset	3780 machines that support 64-bit IEEE floating point arithmetic, @code{eps}\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3781 is approximately\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3782 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3783 2.2204e-16.\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3784 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3785 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3786 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3787 $2.2204\\times10^{-16}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3788 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3789 @end iftex\n\
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3790 for double precision and\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3791 @ifnottex\n\
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3792 1.1921e-07.\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3793 @end ifnottex\n\
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3794 @iftex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3795 @tex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3796 $1.1921\\times10^{-7}$.\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3797 @end tex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3798 @end iftex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3799 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	3800 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	3801 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3802 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3803 int nargin = args.length ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3804 octave_value retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3805
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3806 if (nargin == 1 && ! args(0).is_string ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3807 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3808 if (args(0).is_single_type ())
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 float val = args(0).float_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3811
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3812 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3813 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3814 val = ::fabsf(val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3815 if (xisnan (val) \|\| xisinf (val))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3816 retval = fill_matrix (octave_value ("single"),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3817 lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3818 lo_ieee_float_nan_value (), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3819 else if (val < FLT_MIN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3820 retval = fill_matrix (octave_value ("single"), 0e0,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3821 powf (2.0, -149e0), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3822 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3823 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3824 int expon;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3825 frexpf (val, &expon);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3826 val = std::pow (static_cast <float> (2.0),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3827 static_cast <float> (expon - 24));
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3828 retval = fill_matrix (octave_value ("single"), DBL_EPSILON,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3829 val, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3830 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3831 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3832 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3833 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3834 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3835 double val = args(0).double_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3836
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3837 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3838 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3839 val = ::fabs(val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3840 if (xisnan (val) \|\| xisinf (val))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3841 retval = fill_matrix (octave_value_list (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3842 lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3843 lo_ieee_float_nan_value (), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3844 else if (val < DBL_MIN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3845 retval = fill_matrix (octave_value_list (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3846 pow (2.0, -1074e0), 0e0, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3847 else
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 int expon;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3850 frexp (val, &expon);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3851 val = std::pow (static_cast <double> (2.0),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3852 static_cast <double> (expon - 53));
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3853 retval = fill_matrix (octave_value_list (), val,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3854 FLT_EPSILON, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3855 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3856 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3857 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3858 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3859 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3860 retval = fill_matrix (args, DBL_EPSILON, FLT_EPSILON, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3861
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3862 return retval;
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3863 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3864
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3865 /*
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3866
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3867 %!assert(eps(1/2),2^(-53))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3868 %!assert(eps(1),2^(-52))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3869 %!assert(eps(2),2^(-51))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3870 %!assert(eps(realmax),2^971)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3871 %!assert(eps(0),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3872 %!assert(eps(realmin/2),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3873 %!assert(eps(realmin/16),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3874 %!assert(eps(Inf),NaN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3875 %!assert(eps(NaN),NaN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3876 %!assert(eps(single(1/2)),single(2^(-24)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3877 %!assert(eps(single(1)),single(2^(-23)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3878 %!assert(eps(single(2)),single(2^(-22)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3879 %!assert(eps(realmax('single')),single(2^104))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3880 %!assert(eps(single(0)),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3881 %!assert(eps(realmin('single')/2),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3882 %!assert(eps(realmin('single')/16),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3883 %!assert(eps(single(Inf)),single(NaN))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3884 %!assert(eps(single(NaN)),single(NaN))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3885
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3886 */
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3887
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3888
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3889 DEFUN (pi, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3890 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3891 @deftypefn {Built-in Function} {} pi (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3892 @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	3893 @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	3894 @deftypefnx {Built-in Function} {} pi (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3895 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	3896 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	3897 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	3898 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3899 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3900 #if defined (M_PI)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3901 double pi_val = M_PI;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3902 #else
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3903 double pi_val = 4.0 * atan (1.0);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3904 #endif
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3905
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3906 return fill_matrix (args, pi_val, "pi");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3907 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3908
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3909 DEFUN (realmax, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3910 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3911 @deftypefn {Built-in Function} {} realmax (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3912 @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	3913 @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	3914 @deftypefnx {Built-in Function} {} realmax (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3915 Return a matrix or N-dimensional array whose elements are all equal\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3916 to the 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	3917 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	3918 floating point arithmetic, @code{realmax} is approximately\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3919 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3920 1.7977e+308\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3921 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3922 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3923 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3924 $1.7977\\times10^{308}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3925 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3926 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3927 @seealso{realmin}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3928 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3929 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3930 return fill_matrix (args, DBL_MAX, FLT_MAX, "realmax");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3931 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3932
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3933 DEFUN (realmin, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3934 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3935 @deftypefn {Built-in Function} {} realmin (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3936 @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	3937 @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	3938 @deftypefnx {Built-in Function} {} realmin (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3939 Return a matrix or N-dimensional array whose elements are all equal\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3940 to the smallest normalized floating point number that is representable.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3941 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	3942 64-bit IEEE floating point arithmetic, @code{realmin} is approximately\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3943 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3944 2.2251e-308\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3945 @end ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3946 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3947 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3948 $2.2251\\times10^{-308}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3949 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3950 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3951 @seealso{realmax}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3952 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3953 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3954 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	3955 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3956
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3957 DEFUN (I, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3958 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3959 @deftypefn {Built-in Function} {} I (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3960 @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	3961 @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	3962 @deftypefnx {Built-in Function} {} I (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3963 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	3964 to the pure imaginary unit, defined as\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3965 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3966 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3967 $\\sqrt{-1}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3968 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3969 @end iftex\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3970 @ifnottex\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3971 @code{sqrt (-1)}.\n\
8517 81d6ab3ac93c Allow documentation tobe built for other formats than tex and info sh@sh-laptop parents: 8487 diff changeset	3972 @end ifnottex\n\
7001 8b0cfeb06365 [project @ 2007-10-10 18:02:59 by jwe] jwe parents: 6999 diff changeset	3973 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	3974 other purposes.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3975 @end deftypefn")
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 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	3978 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3979
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3980 DEFALIAS (i, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3981 DEFALIAS (J, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3982 DEFALIAS (j, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3983
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3984 DEFUN (NA, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3985 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3986 @deftypefn {Built-in Function} {} NA (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3987 @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	3988 @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	3989 @deftypefnx {Built-in Function} {} NA (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3990 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	3991 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	3992 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3993 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3994 return fill_matrix (args, lo_ieee_na_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3995 lo_ieee_float_na_value (), "NA");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3996 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3997
7991 139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3998 /*
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3999
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	4000 %!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	4001 %!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	4002
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	4003 */
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	4004
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4005 DEFUN (false, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4006 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4007 @deftypefn {Built-in Function} {} false (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4008 @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	4009 @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	4010 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	4011 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	4012 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4013 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4014 return fill_matrix (args, false, "false");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4015 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4016
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4017 DEFUN (true, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4018 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4019 @deftypefn {Built-in Function} {} true (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4020 @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	4021 @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	4022 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	4023 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	4024 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4025 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	4026 return fill_matrix (args, true, "true");
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4027 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4028
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4029 template <class MT>
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4030 octave_value
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4031 identity_matrix (int nr, int nc)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4032 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4033 octave_value retval;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4034
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4035 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	4036
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4037 if (nr == 1 && nc == 1)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4038 retval = one;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4039 else
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4040 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4041 dim_vector dims (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4042
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4043 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	4044
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4045 MT m (dims, zero);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4046
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4047 if (nr > 0 && nc > 0)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4048 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4049 int n = std::min (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4050
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4051 for (int i = 0; i < n; i++)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4052 m(i,i) = one;
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
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4055 retval = m;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4056 }
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 return retval;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4059 }
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4060
5058 11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4061 #define INSTANTIATE_EYE(T) \
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4062 template octave_value identity_matrix<T> (int, int)
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4063
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4064 INSTANTIATE_EYE (int8NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4065 INSTANTIATE_EYE (uint8NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4066 INSTANTIATE_EYE (int16NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4067 INSTANTIATE_EYE (uint16NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4068 INSTANTIATE_EYE (int32NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4069 INSTANTIATE_EYE (uint32NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4070 INSTANTIATE_EYE (int64NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4071 INSTANTIATE_EYE (uint64NDArray);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4072 INSTANTIATE_EYE (FloatNDArray);
5058 11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4073 INSTANTIATE_EYE (NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4074 INSTANTIATE_EYE (boolNDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4075
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4076 static octave_value
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4077 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	4078 {
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4079 octave_value retval;
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4080
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4081 // 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	4082 // 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	4083 // value.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4084
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4085 if (! error_state)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4086 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4087 switch (dt)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4088 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4089 case oct_data_conv::dt_int8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4090 retval = identity_matrix<int8NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4091 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4092
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4093 case oct_data_conv::dt_uint8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4094 retval = identity_matrix<uint8NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4095 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4096
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4097 case oct_data_conv::dt_int16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4098 retval = identity_matrix<int16NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4099 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4100
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4101 case oct_data_conv::dt_uint16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4102 retval = identity_matrix<uint16NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4103 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4104
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4105 case oct_data_conv::dt_int32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4106 retval = identity_matrix<int32NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4107 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4108
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4109 case oct_data_conv::dt_uint32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4110 retval = identity_matrix<uint32NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4111 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4112
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4113 case oct_data_conv::dt_int64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4114 retval = identity_matrix<int64NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4115 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4116
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4117 case oct_data_conv::dt_uint64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4118 retval = identity_matrix<uint64NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4119 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4120
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4121 case oct_data_conv::dt_single:
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	4122 retval = FloatDiagMatrix (nr, nc, 1.0f);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4123 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4124
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4125 case oct_data_conv::dt_double:
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8347 diff changeset	4126 retval = DiagMatrix (nr, nc, 1.0);
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4127 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4128
4986 fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4129 case oct_data_conv::dt_logical:
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4130 retval = identity_matrix<boolNDArray> (nr, nc);
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4131 break;
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4132
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4133 default:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4134 error ("eye: invalid class name");
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4135 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4136 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4137 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4138
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4139 return retval;
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4140 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4141
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4142 #undef INT_EYE_MATRIX
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4143
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	4144 DEFUN (eye, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4145 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4146 @deftypefn {Built-in Function} {} eye (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4147 @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	4148 @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	4149 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	4150 @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	4151 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	4152 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	4153 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	4154 respectively. For example,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4155 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4156 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4157 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4158 eye (3)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4159 @result{} 1 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4160 0 1 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4161 0 0 1\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4162 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4163 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4164 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4165 The following expressions all produce the same result:\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4166 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4167 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4168 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4169 eye (2)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4170 @equiv{}\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4171 eye (2, 2)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4172 @equiv{}\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4173 eye (size ([1, 2; 3, 4])\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4174 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4175 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4176 \n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4177 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	4178 the specified type, like\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4179 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4180 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4181 val = zeros (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4182 @end example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4183 \n\
6556 8810bbf321ce [project @ 2007-04-20 18:39:40 by jwe] jwe parents: 6518 diff changeset	4184 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	4185 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	4186 with @sc{Matlab}.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4187 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4188 {
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4189 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4190
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4191 int nargin = args.length ();
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4192
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4193 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	4194
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4195 // Check for type information.
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4196
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4197 if (nargin > 0 && args(nargin-1).is_string ())
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4198 {
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4199 std::string nm = args(nargin-1).string_value ();
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4200 nargin--;
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4201
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4202 dt = oct_data_conv::string_to_data_type (nm);
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4203
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4204 if (error_state)
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4205 return retval;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4206 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4207
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4208 switch (nargin)
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4209 {
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	4210 case 0:
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4211 retval = identity_matrix (1, 1, dt);
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	4212 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4213
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	4214 case 1:
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4215 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4216 octave_idx_type nr, nc;
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4217 get_dimensions (args(0), "eye", nr, nc);
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4218
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4219 if (! error_state)
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4220 retval = identity_matrix (nr, nc, dt);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4221 }
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	4222 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4223
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4224 case 2:
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4225 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4226 octave_idx_type nr, nc;
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4227 get_dimensions (args(0), args(1), "eye", nr, nc);
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4228
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4229 if (! error_state)
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4230 retval = identity_matrix (nr, nc, dt);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4231 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4232 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4233
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4234 default:
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4235 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4236 break;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4237 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4238
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4239 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4240 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4241
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4242
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4243 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4244
8459 d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4245 %!assert (full (eye(3)), [1, 0, 0; 0, 1, 0; 0, 0, 1]);
d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4246 %!assert (full (eye(2, 3)), [1, 0, 0; 0, 1, 0]);
d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4247
d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4248 %!assert (full (eye(3,'single')), single([1, 0, 0; 0, 1, 0; 0, 0, 1]));
d17874a6f161 improve indexing of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	4249 %!assert (full (eye(2, 3,'single')), single([1, 0, 0; 0, 1, 0]));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4250
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4251 %!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	4252 %!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	4253
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4254 %!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	4255
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4256 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4257
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	4258 DEFUN (linspace, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4259 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4260 @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	4261 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	4262 @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	4263 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	4264 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	4265 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	4266 value of 100 is used.\n\
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4267 \n\
4455 abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4358 diff changeset	4268 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	4269 \n\
0fcc8d65b571 [project @ 2007-05-16 15:32:09 by jwe] jwe parents: 6561 diff changeset	4270 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	4271 fewer than two values are requested.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4272 @end deftypefn")
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4273 {
3418 ca92c9d3f882 [project @ 2000-01-12 03:07:47 by jwe] jwe parents: 3373 diff changeset	4274 octave_value retval;
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4275
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4276 int nargin = args.length ();
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4277
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4278 octave_idx_type npoints = 100;
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4279
1940 1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4280 if (nargin != 2 && nargin != 3)
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4281 {
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4282 print_usage ();
1940 1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4283 return retval;
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4284 }
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4285
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4286 if (nargin == 3)
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4287 npoints = args(2).idx_type_value ();
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4288
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4289 if (! error_state)
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4290 {
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4291 octave_value arg_1 = args(0);
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4292 octave_value arg_2 = args(1);
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4293
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4294 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	4295 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4296 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	4297 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4298 FloatComplex x1 = arg_1.float_complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4299 FloatComplex x2 = arg_2.float_complex_value ();
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4300
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4301 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4302 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4303 FloatComplexRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4304
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4305 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4306 retval = rv;
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 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4309 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4310 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4311 float x1 = arg_1.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4312 float x2 = arg_2.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4313
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4314 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4315 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4316 FloatRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4317
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4318 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4319 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4320 }
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4321 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4322 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4323 else
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4324 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4325 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	4326 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4327 Complex x1 = arg_1.complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4328 Complex x2 = arg_2.complex_value ();
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4329
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4330 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4331 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4332 ComplexRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4333
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4334 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4335 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4336 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4337 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4338 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4339 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4340 double x1 = arg_1.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4341 double x2 = arg_2.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4342
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4343 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4344 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4345 RowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4346
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4347 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4348 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4349 }
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4350 }
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4351 }
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4352 }
4732 b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	4353 else
b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	4354 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	4355
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4356 return retval;
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4357 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4358
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4359
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4360 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4361
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4362 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4363 %! 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	4364 %! 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	4365 %! 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	4366 %! 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	4367 %! && 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	4368 %! && 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	4369
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4370
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4371 % 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	4372
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4373 %!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	4374 %!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	4375
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4376 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4377 %! 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	4378
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4379 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4380
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4381 // 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	4382 // 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	4383
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4384 DEFUN (resize, args, ,
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4385 "-- texinfo --\n\
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4386 @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	4387 @deftypefnx {Built-in Function} {} resize (@var{x}, @var{m}, @var{n})\n\
8799 f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4388 @deftypefnx {Built-in Function} {} resize (@var{x}, @var{m}, @var{n}, @dots{})\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4389 Resize @var{x} cutting off elements as necessary.\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4390 \n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4391 In the result, element with certain indices is equal to the corresponding\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4392 element of @var{x} if the indices are within the bounds of @var{x};\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4393 otherwise, the element is set to zero.\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4394 \n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4395 In other words, the statement\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4396 \n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4397 @example\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4398 y = resize (x, dv);\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4399 @end example\n\
6174 d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4400 \n\
8799 f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4401 @noindent\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4402 is equivalent to the following code:\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4403 \n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4404 @example\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4405 y = zeros (dv, class (x));\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4406 sz = min (dv, size (x));\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4407 for i = 1:length (sz), idx@{i@} = 1:sz(i); endfor\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4408 y(idx@{:@}) = x(idx@{:@});\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4409 @end example\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4410 \n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4411 @noindent\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4412 but is performed more efficiently.\n\
6174 d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4413 \n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4414 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	4415 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	4416 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	4417 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	4418 the result are @var{m}-by-@var{n}.\n\
8799 f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4419 \n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4420 An object can be resized to more dimensions than it has;\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4421 in such case the missing dimensions are assumed to be 1.\n\
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4422 Resizing an object to fewer dimensions is not possible.\n\
8433 3292bd1bbaa4 Cross reference between postpad and resize Francesco PotortÃ¬ <pot@gnu.org> parents: 8429 diff changeset	4423 @seealso{reshape, postpad}\n\
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4424 @end deftypefn")
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4425 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4426 octave_value retval;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4427 int nargin = args.length ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4428
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4429 if (nargin == 2)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4430 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4431 Array<double> vec = args(1).vector_value ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4432 int ndim = vec.length ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4433 if (ndim == 1)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4434 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4435 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	4436 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4437 retval = retval.resize (dim_vector (m, m), true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4438 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4439 else
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4440 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4441 dim_vector dv;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4442 dv.resize (ndim);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4443 for (int i = 0; i < ndim; i++)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4444 dv(i) = static_cast<octave_idx_type> (vec(i));
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4445 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4446 retval = retval.resize (dv, true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4447 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4448 }
8799 f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4449 else if (nargin > 2)
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4450 {
8799 f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4451 dim_vector dv;
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4452 dv.resize (nargin - 1);
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4453 for (octave_idx_type i = 1; i < nargin; i++)
f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4454 dv(i-1) = static_cast<octave_idx_type> (args(i).scalar_value ());
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4455 if (!error_state)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4456 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4457 retval = args(0);
8799 f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4458 retval = retval.resize (dv, true);
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4459 }
8799 f6dc6eb57045 improve resize & resize on assignment Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	4460
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4461 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4462 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4463 print_usage ();
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4464 return retval;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4465 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4466
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4467 // FIXME -- should use octave_idx_type for dimensions.
5734 a7d2c47371d2 [project @ 2006-04-04 18:29:13 by jwe] jwe parents: 5731 diff changeset	4468
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4469 DEFUN (reshape, args, ,
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4470 "-- texinfo --\n\
6671 9042b00fc45e [project @ 2007-05-30 06:33:29 by jwe] jwe parents: 6630 diff changeset	4471 @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	4472 @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	4473 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	4474 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	4475 column-major order (like Fortran arrays are stored).\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4476 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4477 For example,\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4478 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4479 @example\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4480 @group\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4481 reshape ([1, 2, 3, 4], 2, 2)\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4482 @result{} 1 3\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4483 2 4\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4484 @end group\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4485 @end example\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4486 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4487 @noindent\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4488 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	4489 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	4490 \n\
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4491 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	4492 by an empty argument.\n\
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4493 @end deftypefn")
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 octave_value retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4496
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4497 int nargin = args.length ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4498
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4499 Array<int> new_size;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4500
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4501 if (nargin == 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4502 new_size = args(1).int_vector_value ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4503 else if (nargin > 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4504 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4505 new_size.resize (nargin-1);
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4506 int empty_dim = -1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4507
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4508 for (int i = 1; i < nargin; i++)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4509 {
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4510 if (args(i).is_empty ())
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4511 if (empty_dim > 0)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4512 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4513 error ("reshape: only a single dimension can be unknown");
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4514 break;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4515 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4516 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4517 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4518 empty_dim = i;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4519 new_size(i-1) = 1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4520 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4521 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4522 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4523 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	4524
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4525 if (error_state)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4526 break;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4527 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4528 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4529
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4530 if (! error_state && (empty_dim > 0))
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4531 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4532 int nel = 1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4533 for (int i = 0; i < nargin - 1; i++)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4534 nel *= new_size(i);
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4535
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4536 if (nel == 0)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4537 new_size(empty_dim-1) = 0;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4538 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4539 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4540 int size_empty_dim = args(0).numel () / nel;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4541
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4542 if (args(0).numel () != size_empty_dim * nel)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4543 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	4544 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4545 new_size(empty_dim-1) = size_empty_dim;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4546 }
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4547 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4548 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4549 else
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4550 {
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4551 print_usage ();
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4552 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4553 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4554
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4555 if (error_state)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4556 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4557 error ("reshape: invalid arguments");
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4558 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4559 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4560
4739 7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4561 // 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	4562 // elements.
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4563
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4564 int n = new_size.length ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4565
4739 7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4566 while (n > 2)
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4567 {
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4568 if (new_size(n-1) == 1)
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4569 n--;
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4570 else
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4571 break;
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4572 }
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4573
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4574 new_size.resize (n);
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4575
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4576 if (n < 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4577 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4578 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	4579 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4580 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4581
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4582 dim_vector new_dims;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4583
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4584 new_dims.resize (n);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4585
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4586 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	4587 new_dims(i) = new_size(i);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4588
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4589 octave_value arg = args(0);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4590
8526 17e0ad741fac reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8517 diff changeset	4591 dim_vector dims = arg.dims ();
17e0ad741fac reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8517 diff changeset	4592
17e0ad741fac reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8517 diff changeset	4593 if (new_dims.numel () == dims.numel ())
17e0ad741fac reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8517 diff changeset	4594 retval = (new_dims == dims) ? arg : arg.reshape (new_dims);
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4595 else
8527 6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4596 {
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4597 std::string dims_str = dims.str ();
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4598 std::string new_dims_str = new_dims.str ();
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4599
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4600 error ("reshape: can't reshape %s array to %s array",
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4601 dims_str.c_str (), new_dims_str.c_str ());
6b074f37e8d7 reshape: improve error message John W. Eaton <jwe@octave.org> parents: 8526 diff changeset	4602 }
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4603
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4604 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4605 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4606
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4607 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4608
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4609 %!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	4610 %!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	4611 %!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	4612 %!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	4613
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4614 %!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	4615 %!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	4616 %!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	4617 %!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	4618
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4619 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4620 %! 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	4621 %! 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	4622
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4623 %!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	4624 %!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	4625
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4626 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4627
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4628 DEFUN (squeeze, args, ,
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4629 "-- texinfo --\n\
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4630 @deftypefn {Built-in Function} {} squeeze (@var{x})\n\
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4631 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	4632 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	4633 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	4634 @end deftypefn")
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4635 {
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4636 octave_value retval;
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4637
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4638 if (args.length () == 1)
4545 c16f153836a0 [project @ 2003-10-24 04:45:45 by jwe] jwe parents: 4532 diff changeset	4639 retval = args(0).squeeze ();
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4640 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4641 print_usage ();
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4642
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4643 return retval;
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4644 }
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4645
8458 d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4646 DEFUN (full, args, ,
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4647 "-- texinfo --\n\
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4648 @deftypefn {Loadable Function} {@var{FM} =} full (@var{SM})\n\
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4649 returns a full storage matrix from a sparse, diagonal, permutation matrix or a range.\n\
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4650 @seealso{sparse}\n\
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4651 @end deftypefn")
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4652 {
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4653 octave_value retval;
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4654
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4655 if (args.length () == 1)
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4656 retval = args(0).full_value ();
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4657 else
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4658 print_usage ();
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4659
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4660 return retval;
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4661 }
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8433 diff changeset	4662
6945 6bbf56a9718a [project @ 2007-10-02 20:47:22 by jwe] jwe parents: 6887 diff changeset	4663 // Compute various norms of the vector X.
6bbf56a9718a [project @ 2007-10-02 20:47:22 by jwe] jwe parents: 6887 diff changeset	4664
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4665 DEFUN (norm, args, ,
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4666 "-- texinfo --\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4667 @deftypefn {Function File} {} norm (@var{a}, @var{p}, @var{opt})\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4668 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	4669 missing, @code{p = 2} is assumed.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4670 \n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4671 If @var{a} is a matrix (or sparse matrix):\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4672 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4673 @table @asis\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4674 @item @var{p} = @code{1}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4675 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	4676 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4677 @item @var{p} = @code{2}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4678 Largest singular value of @var{a}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4679 \n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4680 @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	4681 @cindex infinity norm\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4682 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	4683 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4684 @item @var{p} = @code{\"fro\"}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4685 @cindex Frobenius norm\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4686 Frobenius norm of @var{a}, @code{sqrt (sum (diag (@var{a}' * @var{a})))}.\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4687 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4688 @item other @var{p}, @code{@var{p} > 1}\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4689 @cindex general p-norm \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4690 maximum @code{norm (A*x, p)} such that @code{norm (x, p) == 1}\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4691 @end table\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4692 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4693 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	4694 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4695 @table @asis\n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4696 @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	4697 @code{max (abs (@var{a}))}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4698 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4699 @item @var{p} = @code{-Inf}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4700 @code{min (abs (@var{a}))}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4701 \n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4702 @item @var{p} = @code{\"fro\"}\n\
e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4703 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	4704 \n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4705 @item @var{p} = 0\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4706 Hamming norm - the number of nonzero elements.\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4707 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4708 @item other @var{p}, @code{@var{p} > 1}\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4709 p-norm of @var{a}, @code{(sum (abs (@var{a}) .^ @var{p})) ^ (1/@var{p})}.\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4710 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4711 @item other @var{p} @code{@var{p} < 1}\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4712 the p-pseudonorm defined as above.\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4713 @end table\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4714 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4715 If @code{\"rows\"} is given as @var{opt}, the norms of all rows of the matrix @var{a} are\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4716 returned as a column vector. Similarly, if @code{\"columns\"} or @code{\"cols\"} is passed\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4717 column norms are computed.\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4718 @seealso{cond, svd}\n\
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4719 @end deftypefn")
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4720 {
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4721 octave_value_list retval;
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4722
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4723 int nargin = args.length ();
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4724
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4725 if (nargin >= 1 && nargin <= 3)
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4726 {
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4727 octave_value x_arg = args(0);
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4728
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4729 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	4730 {
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4731 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	4732 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	4733 else
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4734 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	4735 }
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4736 else if (x_arg.ndims () == 2)
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4737 {
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4738 enum { sfmatrix, sfcols, sfrows, sffrob, sfinf } strflag = sfmatrix;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4739 if (nargin > 1 && args(nargin-1).is_string ())
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4740 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4741 std::string str = args(nargin-1).string_value ();
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4742 if (str == "cols" \|\| str == "columns")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4743 strflag = sfcols;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4744 else if (str == "rows")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4745 strflag = sfrows;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4746 else if (str == "fro")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4747 strflag = sffrob;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4748 else if (str == "inf")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4749 strflag = sfinf;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4750 else
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4751 error ("norm: unrecognized option: %s", str.c_str ());
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4752 // we've handled the last parameter, so act as if it was removed
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4753 nargin --;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4754 }
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4755 else if (nargin > 1 && ! args(1).is_scalar_type ())
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4756 gripe_wrong_type_arg ("norm", args(1), true);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4757
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4758 if (! error_state)
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4759 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4760 octave_value p_arg = (nargin > 1) ? args(1) : octave_value (2);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4761 switch (strflag)
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4762 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4763 case sfmatrix:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4764 retval(0) = xnorm (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4765 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4766 case sfcols:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4767 retval(0) = xcolnorms (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4768 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4769 case sfrows:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4770 retval(0) = xrownorms (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4771 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4772 case sffrob:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4773 retval(0) = xfrobnorm (x_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4774 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4775 case sfinf:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4776 retval(0) = xnorm (x_arg, octave_Inf);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4777 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4778 }
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4779 }
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4780 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4781 else
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4782 error ("norm: only valid for 2-D objects");
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4783 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4784 else
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4785 print_usage ();
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4786
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4787 return retval;
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4788 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4789
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4790 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4791 %!shared x
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4792 %! 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	4793 %!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	4794 %!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	4795 %!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	4796 %!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	4797 %!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	4798 %!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	4799 %!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	4800 %!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	4801 %!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	4802 %!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	4803 %!shared m
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4804 %! 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	4805 %!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	4806 %!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	4807 %!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	4808 %!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	4809 %!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	4810 %! 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	4811 %! 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	4812 %! 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	4813 %!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	4814 %!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	4815
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4816 %!shared x
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4817 %! 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	4818 %!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	4819 %!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	4820 %!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	4821 %!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	4822 %!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	4823 %!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	4824 %!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	4825 %!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	4826 %!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	4827 %!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	4828 %!shared m
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4829 %! 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	4830 %!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	4831 %!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	4832 %!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	4833 %!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	4834 %!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	4835 %! 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	4836 %! 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	4837 %! 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	4838 %!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	4839 %!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	4840 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4841
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4842 #define UNARY_OP_DEFUN_BODY(F) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4843 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4844 octave_value retval; \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4845 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4846 if (args.length () == 1) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4847 retval = F (args(0)); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4848 else \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4849 print_usage (); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4850 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4851 return retval
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4852
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4853 DEFUN (not, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4854 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4855 @deftypefn {Built-in Function} {} not (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4856 This function is equivalent to @code{! x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4857 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4858 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4859 UNARY_OP_DEFUN_BODY (op_not);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4860 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4861
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4862 DEFUN (uplus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4863 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4864 @deftypefn {Built-in Function} {} uplus (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4865 This function is equivalent to @code{+ x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4866 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4867 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4868 UNARY_OP_DEFUN_BODY (op_uplus);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4869 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4870
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4871 DEFUN (uminus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4872 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4873 @deftypefn {Built-in Function} {} uminus (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4874 This function is equivalent to @code{- x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4875 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4876 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4877 UNARY_OP_DEFUN_BODY (op_uminus);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4878 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4879
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4880 DEFUN (transpose, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4881 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4882 @deftypefn {Built-in Function} {} transpose (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4883 This function is equivalent to @code{x.'}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4884 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4885 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4886 UNARY_OP_DEFUN_BODY (op_transpose);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4887 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4888
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4889 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4890
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4891 %!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	4892 %!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	4893 %!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	4894 %!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	4895 %!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	4896 %!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	4897
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4898 %!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	4899
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4900 %!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	4901 %!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	4902 %!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	4903 %!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	4904 %!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	4905 %!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	4906
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4907 %!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	4908
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4909 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4910
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4911 DEFUN (ctranspose, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4912 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4913 @deftypefn {Built-in Function} {} ctranspose (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4914 This function is equivalent to @code{x'}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4915 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4916 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4917 UNARY_OP_DEFUN_BODY (op_hermitian);
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
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4920 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4921
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4922 %!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	4923 %!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	4924 %!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	4925 %!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	4926 %!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	4927 %!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	4928
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4929 %!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	4930
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4931 %!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	4932 %!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	4933 %!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	4934 %!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	4935 %!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	4936 %!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	4937
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4938 %!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	4939
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4940 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4941
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4942 #define BINARY_OP_DEFUN_BODY(F) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4943 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4944 octave_value retval; \
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 if (args.length () == 2) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4947 retval = F (args(0), args(1)); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4948 else \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4949 print_usage (); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4950 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4951 return retval
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4952
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4953 DEFUN (plus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4954 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4955 @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	4956 This function is equivalent to @code{x + y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4957 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4958 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4959 BINARY_OP_DEFUN_BODY (op_add);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4962 DEFUN (minus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4963 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4964 @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	4965 This function is equivalent to @code{x - y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4966 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4967 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4968 BINARY_OP_DEFUN_BODY (op_sub);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4971 DEFUN (mtimes, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4972 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4973 @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	4974 This function is equivalent to @code{x * y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4975 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4976 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4977 BINARY_OP_DEFUN_BODY (op_mul);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4980 DEFUN (mrdivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4981 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4982 @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	4983 This function is equivalent to @code{x / y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4984 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4985 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4986 BINARY_OP_DEFUN_BODY (op_div);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4989 DEFUN (mpower, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4990 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4991 @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	4992 This function is equivalent to @code{x ^ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4993 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4994 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4995 BINARY_OP_DEFUN_BODY (op_pow);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4998 DEFUN (mldivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4999 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5000 @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	5001 This function is equivalent to @code{x \\ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5002 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5003 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5004 BINARY_OP_DEFUN_BODY (op_ldiv);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5007 DEFUN (lt, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5008 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5009 @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	5010 This function is equivalent to @code{x < y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5011 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5012 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5013 BINARY_OP_DEFUN_BODY (op_lt);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5016 DEFUN (le, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5017 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5018 @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	5019 This function is equivalent to @code{x <= y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5020 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5021 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5022 BINARY_OP_DEFUN_BODY (op_le);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5025 DEFUN (eq, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5026 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5027 @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	5028 This function is equivalent to @code{x == y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5029 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5030 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5031 BINARY_OP_DEFUN_BODY (op_eq);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5034 DEFUN (ge, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5035 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5036 @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	5037 This function is equivalent to @code{x >= y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5038 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5039 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5040 BINARY_OP_DEFUN_BODY (op_ge);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5043 DEFUN (gt, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5044 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5045 @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	5046 This function is equivalent to @code{x > y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5047 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5048 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5049 BINARY_OP_DEFUN_BODY (op_gt);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5052 DEFUN (ne, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5053 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5054 @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	5055 This function is equivalent to @code{x != y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5056 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5057 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5058 BINARY_OP_DEFUN_BODY (op_ne);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5061 DEFUN (times, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5062 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5063 @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	5064 This function is equivalent to @code{x .* y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5065 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5066 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5067 BINARY_OP_DEFUN_BODY (op_el_mul);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5068 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5069
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5070 DEFUN (rdivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5071 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5072 @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	5073 This function is equivalent to @code{x ./ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5074 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5075 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5076 BINARY_OP_DEFUN_BODY (op_el_div);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5077 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5078
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5079 DEFUN (power, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5080 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5081 @deftypefn {Built-in Function} {} power (@var{x}, @var{y})\n\
7623 431f3788f5c4 minor doc patch David Bateman <dbateman@free.fr> parents: 7620 diff changeset	5082 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	5083 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5084 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5085 BINARY_OP_DEFUN_BODY (op_el_pow);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5086 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5087
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5088 DEFUN (ldivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5089 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5090 @deftypefn {Built-in Function} {} ldivide (@var{x}, @var{y})\n\
7623 431f3788f5c4 minor doc patch David Bateman <dbateman@free.fr> parents: 7620 diff changeset	5091 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	5092 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5093 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5094 BINARY_OP_DEFUN_BODY (op_el_ldiv);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5095 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5096
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5097 DEFUN (and, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5098 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5099 @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	5100 This function is equivalent to @code{x & y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5101 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5102 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5103 BINARY_OP_DEFUN_BODY (op_el_and);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5104 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5105
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5106 DEFUN (or, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5107 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5108 @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	5109 This function is equivalent to @code{x \| y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5110 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5111 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5112 BINARY_OP_DEFUN_BODY (op_el_or);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5113 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5114
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5115 static double tic_toc_timestamp = -1.0;
7045 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 DEFUN (tic, args, nargout,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5118 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5119 @deftypefn {Built-in Function} {} tic ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5120 @deftypefnx {Built-in Function} {} toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5121 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	5122 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	5123 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	5124 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5125 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5126 tic ();\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5127 # many computations later...\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5128 elapsed_time = toc ();\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5129 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5130 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5131 @noindent\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5132 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	5133 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	5134 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5135 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	5136 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	5137 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5138 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5139 @group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5140 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	5141 @result{} 5\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5142 @end group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5143 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5144 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5145 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	5146 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	5147 recent call to @code{tic}.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5148 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5149 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	5150 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	5151 @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	5152 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	5153 doing nothing at all. For example,\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5154 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5155 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5156 @group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5157 tic (); sleep (5); toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5158 @result{} 5\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5159 t = cputime (); sleep (5); cputime () - t\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5160 @result{} 0\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5161 @end group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5162 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5163 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5164 @noindent\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5165 (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	5166 coarse resolution.)\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5167 @end deftypefn")
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 octave_value retval;
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5170
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5171 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5172
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5173 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5174 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5175
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5176 octave_time now;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5177
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5178 double tmp = now.double_value ();
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5179
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5180 if (nargout > 0)
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5181 retval = static_cast<octave_uint64> (1e6 * tmp);
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5182 else
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5183 tic_toc_timestamp = tmp;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5184
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5185 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5186 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5187
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5188 DEFUN (toc, args, nargout,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5189 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5190 @deftypefn {Built-in Function} {} toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5191 See tic.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5192 @end deftypefn")
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 octave_value retval;
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5195
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5196 int nargin = args.length ();
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 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5199 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5200
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5201 if (tic_toc_timestamp < 0)
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5202 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5203 warning ("toc called before timer set");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5204 if (nargout > 0)
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5205 retval = Matrix ();
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5206 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5207 else
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5208 {
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5209 octave_time now;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5210
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5211 double tmp = now.double_value () - tic_toc_timestamp;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5212
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5213 if (nargout > 0)
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5214 retval = tmp;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5215 else
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5216 octave_stdout << "Elapsed time is " << tmp << " seconds.\n";
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5217 }
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5218
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5219 return retval;
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
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5222 DEFUN (cputime, args, ,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5223 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5224 @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	5225 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	5226 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	5227 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	5228 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	5229 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	5230 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	5231 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	5232 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	5233 CPU time used is nonzero.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5234 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5235 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5236 octave_value_list retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5237 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5238 double usr = 0.0;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5239 double sys = 0.0;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5240
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5241 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5242 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5243
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5244 #if defined (HAVE_GETRUSAGE)
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 struct rusage ru;
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 getrusage (RUSAGE_SELF, &ru);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5249
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5250 usr = static_cast<double> (ru.ru_utime.tv_sec) +
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5251 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	5252
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5253 sys = static_cast<double> (ru.ru_stime.tv_sec) +
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5254 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	5255
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5256 #elif defined (HAVE_TIMES) && defined (HAVE_SYS_TIMES_H)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5257
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5258 struct tms t;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5259
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5260 times (&t);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5261
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5262 unsigned long ticks;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5263 unsigned long seconds;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5264 unsigned long fraction;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5265
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5266 ticks = t.tms_utime + t.tms_cutime;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5267 fraction = ticks % HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5268 seconds = ticks / HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5269
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5270 usr = static_cast<double> (seconds) + static_cast<double>(fraction) /
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5271 static_cast<double>(HZ);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5272
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5273 ticks = t.tms_stime + t.tms_cstime;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5274 fraction = ticks % HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5275 seconds = ticks / HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5276
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5277 sys = static_cast<double> (seconds) + static_cast<double>(fraction) /
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5278 static_cast<double>(HZ);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5279
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5280 #elif defined (__WIN32__)
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5281
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5282 HANDLE hProcess = GetCurrentProcess ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5283 FILETIME ftCreation, ftExit, ftUser, ftKernel;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5284 GetProcessTimes (hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5285
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5286 int64_t itmp = (reinterpret_cast<int64_t > (&ftUser));
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5287 usr = static_cast<double> (itmp) * 1e-7;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5288
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5289 itmp = (reinterpret_cast<int64_t > (&ftKernel));
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5290 sys = static_cast<double> (itmp) * 1e-7;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5291
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5292 #endif
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5293
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5294 retval (2) = sys;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5295 retval (1) = usr;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5296 retval (0) = sys + usr;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5297
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5298 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5299 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5300
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5301 DEFUN (sort, args, nargout,
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5302 "-- texinfo --\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5303 @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	5304 @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	5305 @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	5306 @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	5307 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	5308 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	5309 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5310 For example,\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5311 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5312 @example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5313 @group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5314 sort ([1, 2; 2, 3; 3, 1])\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5315 @result{} 1 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5316 2 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5317 3 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5318 @end group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5319 @end example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5320 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5321 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	5322 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	5323 matrix. For example,\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5324 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5325 @example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5326 @group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5327 [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	5328 @result{} s = 1 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5329 2 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5330 3 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5331 @result{} i = 1 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5332 2 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5333 3 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5334 @end group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5335 @end example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5336 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5337 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	5338 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	5339 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	5340 @code{mode} are `ascend' or `descend'.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5341 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5342 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	5343 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	5344 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5345 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	5346 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	5347 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5348 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	5349 ordered lists.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5350 @end deftypefn")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5351 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5352 octave_value_list retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5353
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5354 int nargin = args.length ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5355 sortmode smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5356
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5357 if (nargin < 1 \|\| nargin > 3)
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 print_usage ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5360 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5361 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5362
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5363 bool return_idx = nargout > 1;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5364
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5365 octave_value arg = args(0);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5366
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5367 int dim = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5368 if (nargin > 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5369 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5370 if (args(1).is_string ())
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 std::string mode = args(1).string_value();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5373 if (mode == "ascend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5374 smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5375 else if (mode == "descend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5376 smode = DESCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5377 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5378 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5379 error ("sort: mode must be either \"ascend\" or \"descend\"");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5380 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5381 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5382 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5383 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5384 dim = args(1).nint_value () - 1;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5385 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5386
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5387 if (nargin > 2)
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 if (args(1).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5390 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5391 print_usage ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5392 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5393 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5394
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5395 if (! args(2).is_string ())
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 error ("sort: mode must be a string");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5398 return retval;
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 std::string mode = args(2).string_value();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5401 if (mode == "ascend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5402 smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5403 else if (mode == "descend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5404 smode = DESCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5405 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5406 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5407 error ("sort: mode must be either \"ascend\" or \"descend\"");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5408 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5409 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5410 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5411
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5412 dim_vector dv = arg.dims ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5413 if (error_state)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5414 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5415 gripe_wrong_type_arg ("sort", arg);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5416 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5417 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5418 if (nargin == 1 \|\| args(1).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5419 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5420 // Find first non singleton dimension
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5421 for (int i = 0; i < dv.length (); i++)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5422 if (dv(i) > 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5423 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5424 dim = i;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5425 break;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5426 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5427 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5428 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5429 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5430 if (dim < 0 \|\| dim > dv.length () - 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5431 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5432 error ("sort: dim must be a valid dimension");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5433 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5434 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5435 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5436
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5437 if (return_idx)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5438 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5439 Array<octave_idx_type> sidx;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5440
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5441 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	5442 retval (1) = NDArray (sidx, true);
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5443 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5444 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5445 retval(0) = arg.sort (dim, smode);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5446
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5447 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5448 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5449
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5450 /*
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5451
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5452 %% Double
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5453 %!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	5454 %!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	5455 %!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	5456 %!error (sort ([NaN, 1, -1, 2, Inf], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5457 %!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	5458 %!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	5459 %!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	5460 %!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	5461 %!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	5462 %!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	5463 %!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	5464 %!assert (sort (1), 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5465
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5466 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5467 %! [v, i] = sort ([NaN, 1, -1, Inf, 1]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5468 %! assert (v, [-1, 1, 1, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5469 %! assert (i, [3, 2, 5, 4, 1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5470
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5471 %% Complex
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5472 %!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	5473 %!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	5474 %!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	5475 %!error (sort ([NaN, 1i, -1, 2, Inf], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5476 %!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	5477 %!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	5478 %!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	5479 %!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	5480 %!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	5481 %!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	5482 %!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	5483 %!assert (sort (1i), 1i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5484
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5485 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5486 %! [v, i] = sort ([NaN, 1i, -1, Inf, 1, 1i]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5487 %! assert (v, [1, 1i, 1i, -1, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5488 %! assert (i, [5, 2, 6, 3, 4, 1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5489
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5490 %% Single
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5491 %!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	5492 %!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	5493 %!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	5494 %!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	5495 %!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	5496 %!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	5497 %!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	5498 %!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	5499 %!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	5500 %!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	5501 %!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	5502 %!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	5503
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5504 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5505 %! [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	5506 %! 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	5507 %! 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	5508
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5509 %% Single Complex
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5510 %!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	5511 %!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	5512 %!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	5513 %!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	5514 %!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	5515 %!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	5516 %!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	5517 %!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	5518 %!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	5519 %!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	5520 %!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	5521 %!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	5522
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5523 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5524 %! [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	5525 %! 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	5526 %! 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	5527
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5528 %% Bool
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5529 %!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	5530 %!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	5531 %!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	5532 %!error (sort ([true, false, true, false], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5533 %!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	5534 %!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	5535 %!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	5536 %!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	5537 %!assert (sort (true), true)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5538
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5539 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5540 %! [v, i] = sort ([true, false, true, false]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5541 %! assert (v, [false, false, true, true])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5542 %! assert (i, [2, 4, 1, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5543
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5544 %% Sparse Double
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5545 %!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	5546 %!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	5547 %!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	5548 %!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	5549 %!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	5550 %!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	5551 %!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	5552 %!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	5553
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5554 %!shared a
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5555 %! a = randn (10, 10);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5556 %! a (a < 0) = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5557 %!assert (sort (sparse (a)), sparse (sort (a)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5558 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5559 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5560 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5561 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5562 %! [vs, is] = sort (sparse (a));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5563 %! assert (vs, sparse (v))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5564 %! assert (is, i)
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 %% Sparse Complex
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5567 %!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	5568 %!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	5569 %!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	5570 %!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	5571 %!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	5572 %!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	5573 %!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	5574 %!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	5575
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5576 %!shared a
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5577 %! a = randn (10, 10);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5578 %! a (a < 0) = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5579 %! a = 1i * a;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5580 %!assert (sort (sparse (a)), sparse (sort (a)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5581 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5582 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5583 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5584 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5585 %! [vs, is] = sort (sparse (a));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5586 %! assert (vs, sparse (v))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5587 %! assert (is, i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5588
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5589 %% Sparse Bool
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5590 %!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	5591 %!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	5592 %!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	5593 %!error (sort (sparse ([true, false, true, false], 3)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5594 %!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	5595 %!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	5596 %!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	5597 %!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	5598
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5599 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5600 %! [v, i] = sort (sparse([true, false, true, false]));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5601 %! assert (v, sparse([false, false, true, true]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5602 %! assert (i, [2, 4, 1, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5603
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5604 %% Cell string array
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5605 %!shared a, b, c
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5606 %! a = {"Alice", "Cecile", "Eric", "Barry", "David"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5607 %! b = {"Alice", "Barry", "Cecile", "David", "Eric"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5608 %! c = {"Eric", "David", "Cecile", "Barry", "Alice"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5609 %!assert (sort (a), b);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5610 %!assert (sort (a, 1), a)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5611 %!assert (sort (a, 2), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5612 %!error (sort (a, 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5613 %!assert (sort (a, "ascend"), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5614 %!assert (sort (a, 2, "ascend"), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5615 %!assert (sort (a, "descend"), c)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5616 %!assert (sort (a, 2, "descend"), c)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5617
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5618 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5619 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5620 %! assert (i, [1, 4, 2, 5, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5621
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5622 %!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	5623 %!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	5624
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5625 */
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5626
8812 7d48766c21a5 use consistent format for doc strings of internal functions John W. Eaton <jwe@octave.org> parents: 8799 diff changeset	5627 // Sort the rows of the matrix @var{a} according to the order
7d48766c21a5 use consistent format for doc strings of internal functions John W. Eaton <jwe@octave.org> parents: 8799 diff changeset	5628 // specified by @var{mode}, which can either be `ascend' or `descend'
7d48766c21a5 use consistent format for doc strings of internal functions John W. Eaton <jwe@octave.org> parents: 8799 diff changeset	5629 // and return the index vector corresponding to the sort order.
7d48766c21a5 use consistent format for doc strings of internal functions John W. Eaton <jwe@octave.org> parents: 8799 diff changeset	5630 //
7d48766c21a5 use consistent format for doc strings of internal functions John W. Eaton <jwe@octave.org> parents: 8799 diff changeset	5631 // This function does not yet support sparse matrices.
7d48766c21a5 use consistent format for doc strings of internal functions John W. Eaton <jwe@octave.org> parents: 8799 diff changeset	5632
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5633 DEFUN (__sort_rows_idx__, args, ,
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5634 "-- texinfo --\n\
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5635 @deftypefn {Function File} {} __sort_rows_idx__ (@var{a}, @var{mode})\n\
8812 7d48766c21a5 use consistent format for doc strings of internal functions John W. Eaton <jwe@octave.org> parents: 8799 diff changeset	5636 Undocumented internal function.\n\
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5637 @end deftypefn\n")
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5638 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5639 octave_value retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5640
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5641 int nargin = args.length ();
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5642 sortmode smode = ASCENDING;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5643
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5644 if (nargin < 1 \|\| nargin > 2 \|\| (nargin == 2 && ! args(1).is_string ()))
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5645 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5646 print_usage ();
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5647 return retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5648 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5649
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5650 if (nargin > 1)
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5651 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5652 std::string mode = args(1).string_value();
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5653 if (mode == "ascend")
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5654 smode = ASCENDING;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5655 else if (mode == "descend")
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5656 smode = DESCENDING;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5657 else
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5658 {
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5659 error ("__sort_rows_idx__: mode must be either \"ascend\" or \"descend\"");
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5660 return retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5661 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5662 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5663
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5664 octave_value arg = args(0);
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5665
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5666 if (arg.is_sparse_type ())
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5667 error ("__sort_rows_idx__: sparse matrices not yet supported");
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5668 if (arg.ndims () == 2)
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5669 {
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5670 Array<octave_idx_type> idx = arg.sort_rows_idx (smode);
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5671
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5672 retval = NDArray (idx, true);
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5673 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5674 else
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	5675 error ("__sort_rows_idx__: needs a 2-dimensional object");
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5676
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5677 return retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5678 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5679
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5680 DEFUN (issorted, args, ,
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5681 "-- texinfo --\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5682 @deftypefn {Function File} {} issorted (@var{a}, @var{rows})\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5683 Returns true if the array is sorted, ascending or descending.\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5684 NaNs are treated is by @code{sort}. If @var{rows} is supplied and\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5685 has the value \"rows\", checks whether the array is sorted by rows\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5686 as if output by @code{sortrows} (with no options).\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5687 \n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5688 This function does not yet support sparse matrices.\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5689 @seealso{sortrows, sort}\n\
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5690 @end deftypefn\n")
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5691 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5692 octave_value retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5693
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5694 int nargin = args.length ();
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5695
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5696 if (nargin == 1)
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5697 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5698 octave_value arg = args(0);
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5699 if (arg.dims ().is_vector ())
8734 767ed8cc6634 rename internal issorted and issorted_rows functions to is_sorted and is_sorted_rows John W. Eaton <jwe@octave.org> parents: 8733 diff changeset	5700 retval = args(0).is_sorted () != UNSORTED;
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5701 else
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5702 error ("issorted: needs a vector");
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5703 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5704 else if (nargin == 2)
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5705 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5706 if (args(1).is_string () && args(1).string_value () == "rows")
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5707 {
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5708 octave_value arg = args(0);
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5709 sortmode smode = ASCENDING;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5710
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5711 if (arg.is_sparse_type ())
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5712 error ("issorted: sparse matrices not yet supported");
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5713 if (arg.ndims () == 2)
8734 767ed8cc6634 rename internal issorted and issorted_rows functions to is_sorted and is_sorted_rows John W. Eaton <jwe@octave.org> parents: 8733 diff changeset	5714 retval = arg.is_sorted_rows (smode) != UNSORTED;
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5715 else
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5716 error ("issorted: needs a 2-dimensional object");
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5717 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5718 else
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5719 error ("issorted: second argument must be \"rows\"");
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5720 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5721 else
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5722 print_usage ();
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5723
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5724 return retval;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5725 }
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5726
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5727
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8527 diff changeset	5728
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5729 /*
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5730 ;;; Local Variables: ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5731 ;;; mode: C++ ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5732 ;;; End: ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5733 */

Mercurial > hg > octave-lyh

annotate src/data.cc @ 8920:eb63fbe60fab