octave: src/data.cc annotate

annotate src/data.cc @ 8347:fa78cb8d8a5c

corrections for typos Here is a patch with some corrections for typos and missing/extra words in the manual. changeset: 8347:34fd1d1c2294 user: Brian Gough <bjg@gnu.org> date: Wed Nov 26 11:00:15 2008 -0500 summary: [docs] can not => cannot

author	Brian Gough<bjg@network-theory.co.uk>
date	Thu, 27 Nov 2008 10:28:24 +0100
parents	b11c31849b44
children	8b1a2555c4e2

rev	line source
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1 /*
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2
7017 a1dbe9d80eee [project @ 2007-10-12 21:27:11 by jwe] jwe parents: 7016 diff changeset	3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
a1dbe9d80eee [project @ 2007-10-12 21:27:11 by jwe] jwe parents: 7016 diff changeset	4 2003, 2004, 2005, 2006, 2007 John W. Eaton
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	6 This file is part of Octave.
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	7
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	8 Octave is free software; you can redistribute it and/or modify it
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	9 under the terms of the GNU General Public License as published by the
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	10 Free Software Foundation; either version 3 of the License, or (at your
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	11 option) any later version.
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	12
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	13 Octave is distributed in the hope that it will be useful, but WITHOUT
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	16 for more details.
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	17
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	18 You should have received a copy of the GNU General Public License
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	19 along with Octave; see the file COPYING. If not, see
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7007 diff changeset	20 <http://www.gnu.org/licenses/>.
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	21
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	22 */
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	23
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	24 #ifdef HAVE_CONFIG_H
1192 b6360f2d4fa6 [project @ 1995-03-30 21:38:35 by jwe] jwe parents: 1129 diff changeset	25 #include <config.h>
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	26 #endif
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	27
7078 405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	28 #include "systime.h"
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	29
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	30 #ifdef HAVE_SYS_TYPES_H
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	31 #include <sys/types.h>
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	32 #endif
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	33
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	34 #ifdef HAVE_SYS_RESOURCE_H
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	35 #include <sys/resource.h>
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	36 #endif
405cf85b435c [project @ 2007-10-30 14:04:59 by jwe] jwe parents: 7065 diff changeset	37
2184 dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	38 #include <cfloat>
dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	39
1728 42b4f904f1af [project @ 1996-01-09 11:36:01 by jwe] jwe parents: 1572 diff changeset	40 #include <string>
42b4f904f1af [project @ 1996-01-09 11:36:01 by jwe] jwe parents: 1572 diff changeset	41
2184 dbbbb3559ee8 [project @ 1996-05-14 02:18:22 by jwe] jwe parents: 2086 diff changeset	42 #include "lo-ieee.h"
7231 2eb392d058bb [project @ 2007-11-30 18:53:29 by jwe] jwe parents: 7189 diff changeset	43 #include "lo-math.h"
1755 3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe] jwe parents: 1742 diff changeset	44 #include "str-vec.h"
4153 6b96ce9f5743 [project @ 2002-11-06 20:38:49 by jwe] jwe parents: 4114 diff changeset	45 #include "quit.h"
1755 3a9462b655f1 [project @ 1996-01-22 04:47:22 by jwe] jwe parents: 1742 diff changeset	46
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	47 #include "Cell.h"
1352 19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	48 #include "defun.h"
19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	49 #include "error.h"
19c10b8657d5 [project @ 1995-09-05 08:11:57 by jwe] jwe parents: 1315 diff changeset	50 #include "gripes.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	51 #include "oct-map.h"
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	52 #include "oct-obj.h"
2366 c90105b99479 [project @ 1996-10-11 23:22:27 by jwe] jwe parents: 2305 diff changeset	53 #include "ov.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	54 #include "ov-float.h"
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	55 #include "ov-complex.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	56 #include "ov-flt-complex.h"
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	57 #include "ov-cx-mat.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	58 #include "ov-flt-cx-mat.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	59 #include "ov-cx-sparse.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	60 #include "parse.h"
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	61 #include "pt-mat.h"
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	62 #include "utils.h"
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	63 #include "variables.h"
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	64 #include "pager.h"
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	65 #include "xnorm.h"
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	66
7914 e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	67 #if ! defined (HAVE_HYPOTF) && defined (HAVE__HYPOTF)
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	68 #define hypotf _hypotf
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	69 #define HAVE_HYPOTF 1
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	70 #endif
e998e81224b5 Various compilation fixes for MSVC. John W. Eaton <jwe@octave.org> parents: 7815 diff changeset	71
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	72 #define ANY_ALL(FCN) \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	73 \
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	74 octave_value retval; \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	75 \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	76 int nargin = args.length (); \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	77 \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	78 if (nargin == 1 \|\| nargin == 2) \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	79 { \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	80 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	81 \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	82 if (! error_state) \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	83 { \
4556 773a21e4fce8 [project @ 2003-10-28 05:02:10 by jwe] jwe parents: 4554 diff changeset	84 if (dim >= -1) \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	85 retval = args(0).FCN (dim); \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	86 else \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	87 error (#FCN ": invalid dimension argument = %d", dim + 1); \
963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	88 } \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	89 else \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	90 error (#FCN ": expecting dimension argument to be an integer"); \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	91 } \
4021 963507f8caf4 [project @ 2002-08-05 22:22:16 by jwe] jwe parents: 4015 diff changeset	92 else \
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	93 print_usage (); \
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	94 \
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	95 return retval
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	96
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	97 DEFUN (all, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	98 "-- texinfo --\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	99 @deftypefn {Built-in Function} {} all (@var{x}, @var{dim})\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	100 The function @code{all} behaves like the function @code{any}, except\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	101 that it returns true only if all the elements of a vector, or all the\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	102 elements along dimension @var{dim} of a matrix, are nonzero.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	103 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	104 {
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	105 ANY_ALL (all);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	106 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	107
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	108 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	109
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	110 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	111 %! x = ones (3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	112 %! x(1,1) = 0;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	113 %! assert((all (all (rand (3) + 1) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	114 %! && all (all (x) == [0, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	115 %! && all (x, 1) == [0, 1, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	116 %! && all (x, 2) == [0; 1; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	117
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	118 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	119 %! x = ones (3, 'single');
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	120 %! x(1,1) = 0;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	121 %! assert((all (all (single (rand (3) + 1)) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	122 %! && all (all (x) == [0, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	123 %! && all (x, 1) == [0, 1, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	124 %! && all (x, 2) == [0; 1; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	125
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	126 %!error <Invalid call to all.*> all ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	127 %!error <Invalid call to all.*> all (1, 2, 3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	128
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	129 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	130
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	131 DEFUN (any, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	132 "-- texinfo --\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	133 @deftypefn {Built-in Function} {} any (@var{x}, @var{dim})\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	134 For a vector argument, return 1 if any element of the vector is\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	135 nonzero.\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	136 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	137 For a matrix argument, return a row vector of ones and\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	138 zeros with each element indicating whether any of the elements of the\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	139 corresponding column of the matrix are nonzero. For example,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	140 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	141 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	142 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	143 any (eye (2, 4))\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	144 @result{} [ 1, 1, 0, 0 ]\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	145 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	146 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	147 \n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	148 If the optional argument @var{dim} is supplied, work along dimension\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	149 @var{dim}. For example,\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	150 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	151 @example\n\
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	152 @group\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	153 any (eye (2, 4), 2)\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	154 @result{} [ 1; 1 ]\n\
6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	155 @end group\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	156 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	157 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	158 {
4015 6476dd85a65f [project @ 2002-08-02 07:59:19 by jwe] jwe parents: 3972 diff changeset	159 ANY_ALL (any);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	160 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	161
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	162 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	163
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	164 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	165 %! x = zeros (3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	166 %! x(3,3) = 1;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	167 %! assert((all (any (x) == [0, 0, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	168 %! && all (any (ones (3)) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	169 %! && any (x, 1) == [0, 0, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	170 %! && any (x, 2) == [0; 0; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	171
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	172 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	173 %! x = zeros (3,'single');
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	174 %! x(3,3) = 1;
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	175 %! assert((all (any (x) == [0, 0, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	176 %! && all (any (ones (3, 'single')) == [1, 1, 1]) == 1
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	177 %! && any (x, 1) == [0, 0, 1]
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	178 %! && any (x, 2) == [0; 0; 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	179
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	180 %!error <Invalid call to any.*> any ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	181 %!error <Invalid call to any.*> any (1, 2, 3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	182
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	183 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	184
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	185 // These mapping functions may also be useful in other places, eh?
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	186
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	187 typedef double (*d_dd_fcn) (double, double);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	188 typedef float (*f_ff_fcn) (float, float);
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	189
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	190 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	191 map_d_m (d_dd_fcn f, double x, const NDArray& y)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	192 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	193 NDArray retval (y.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	194 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	195
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	196 const double *y_data = y.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	197
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	198 octave_idx_type nel = y.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	199
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	200 for (octave_idx_type i = 0; i < nel; i++)
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	201 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	202 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	203 r_data[i] = f (x, y_data[i]);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	204 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	205
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	206 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	207 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	208
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	209 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	210 map_f_fm (f_ff_fcn f, float x, const FloatNDArray& y)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	211 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	212 FloatNDArray retval (y.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	213 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	214
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	215 const float *y_data = y.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	216
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	217 octave_idx_type nel = y.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	218
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	219 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	220 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	221 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	222 r_data[i] = f (x, y_data[i]);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	223 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	224
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	225 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	226 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	227
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	228 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	229 map_m_d (d_dd_fcn f, const NDArray& x, double y)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	230 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	231 NDArray retval (x.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	232 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	233
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	234 const double *x_data = x.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	235
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	236 octave_idx_type nel = x.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	237
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	238 for (octave_idx_type i = 0; i < nel; i++)
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	239 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	240 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	241 r_data[i] = f (x_data[i], y);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	242 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	243
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	244 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	245 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	246
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	247 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	248 map_fm_f (f_ff_fcn f, const FloatNDArray& x, float y)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	249 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	250 FloatNDArray retval (x.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	251 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	252
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	253 const float *x_data = x.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	254
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	255 octave_idx_type nel = x.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	256
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	257 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	258 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	259 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	260 r_data[i] = f (x_data[i], y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	261 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	262
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	263 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	264 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	265
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	266 static NDArray
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	267 map_m_m (d_dd_fcn f, const NDArray& x, const NDArray& y)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	268 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	269 assert (x.dims () == y.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	270
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	271 NDArray retval (x.dims ());
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	272 double *r_data = retval.fortran_vec ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	273
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	274 const double *x_data = x.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	275 const double *y_data = y.data ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	276
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	277 octave_idx_type nel = x.numel ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	278
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	279 for (octave_idx_type i = 0; i < nel; i++)
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	280 {
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	281 OCTAVE_QUIT;
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	282 r_data[i] = f (x_data[i], y_data[i]);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	283 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	284
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	285 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	286 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	287
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	288 static FloatNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	289 map_fm_fm (f_ff_fcn f, const FloatNDArray& x, const FloatNDArray& y)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	290 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	291 assert (x.dims () == y.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	292
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	293 FloatNDArray retval (x.dims ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	294 float *r_data = retval.fortran_vec ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	295
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	296 const float *x_data = x.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	297 const float *y_data = y.data ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	298
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	299 octave_idx_type nel = x.numel ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	300
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	301 for (octave_idx_type i = 0; i < nel; i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	302 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	303 OCTAVE_QUIT;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	304 r_data[i] = f (x_data[i], y_data[i]);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	305 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	306
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	307 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	308 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	309
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	310 static SparseMatrix
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	311 map_d_s (d_dd_fcn f, double x, const SparseMatrix& y)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	312 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	313 octave_idx_type nr = y.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	314 octave_idx_type nc = y.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	315 SparseMatrix retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	316 double f_zero = f (x, 0.);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	317
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	318 if (f_zero != 0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	319 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	320 retval = SparseMatrix (nr, nc, f_zero);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	321
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	322 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	323 for (octave_idx_type i = y.cidx (j); i < y.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	324 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	325 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	326 retval.data (y.ridx(i) + j * nr) = f (x, y.data (i));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	327 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	328
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	329 retval.maybe_compress (true);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	330 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	331 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	332 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	333 octave_idx_type nz = y.nnz ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	334 retval = SparseMatrix (nr, nc, nz);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	335 octave_idx_type ii = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	336 retval.cidx (ii) = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	337
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	338 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	339 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	340 for (octave_idx_type i = y.cidx (j); i < y.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	341 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	342 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	343 double val = f (x, y.data (i));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	344
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	345 if (val != 0.0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	346 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	347 retval.data (ii) = val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	348 retval.ridx (ii++) = y.ridx (i);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	349 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	350 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	351 retval.cidx (j + 1) = ii;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	352 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	353
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	354 retval.maybe_compress (false);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	355 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	356
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	357 return retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	358 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	359
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	360 static SparseMatrix
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	361 map_s_d (d_dd_fcn f, const SparseMatrix& x, double y)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	362 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	363 octave_idx_type nr = x.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	364 octave_idx_type nc = x.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	365 SparseMatrix retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	366 double f_zero = f (0., y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	367
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	368 if (f_zero != 0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	369 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	370 retval = SparseMatrix (nr, nc, f_zero);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	371
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	372 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	373 for (octave_idx_type i = x.cidx (j); i < x.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	374 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	375 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	376 retval.data (x.ridx(i) + j * nr) = f (x.data (i), y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	377 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	378
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	379 retval.maybe_compress (true);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	380 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	381 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	382 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	383 octave_idx_type nz = x.nnz ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	384 retval = SparseMatrix (nr, nc, nz);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	385 octave_idx_type ii = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	386 retval.cidx (ii) = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	387
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	388 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	389 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	390 for (octave_idx_type i = x.cidx (j); i < x.cidx (j+1); i++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	391 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	392 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	393 double val = f (x.data (i), y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	394
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	395 if (val != 0.0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	396 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	397 retval.data (ii) = val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	398 retval.ridx (ii++) = x.ridx (i);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	399 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	400 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	401 retval.cidx (j + 1) = ii;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	402 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	403
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	404 retval.maybe_compress (false);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	405 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	406
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	407 return retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	408 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	409
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	410 static SparseMatrix
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	411 map_s_s (d_dd_fcn f, const SparseMatrix& x, const SparseMatrix& y)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	412 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	413 octave_idx_type nr = x.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	414 octave_idx_type nc = x.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	415
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	416 octave_idx_type y_nr = y.rows ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	417 octave_idx_type y_nc = y.columns ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	418
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	419 assert (nr == y_nr && nc == y_nc);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	420
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	421 SparseMatrix retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	422 double f_zero = f (0., 0.);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	423
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	424 if (f_zero != 0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	425 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	426 retval = SparseMatrix (nr, nc, f_zero);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	427 octave_idx_type k1 = 0, k2 = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	428
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	429 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	430 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	431 while (k1 < x.cidx(j+1) && k2 < y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	432 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	433 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	434 if (k1 >= x.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	435 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	436 retval.data (y.ridx(k2) + j * nr) = f (0.0, y.data (k2));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	437 k2++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	438 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	439 else if (k2 >= y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	440 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	441 retval.data (x.ridx(k1) + j * nr) = f (x.data (k1), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	442 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	443 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	444 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	445 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	446 octave_idx_type rx = x.ridx(k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	447 octave_idx_type ry = y.ridx(k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	448
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	449 if (rx < ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	450 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	451 retval.data (rx + j * nr) = f (x.data (k1), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	452 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	453 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	454 else if (rx > ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	455 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	456 retval.data (ry + j * nr) = f (0.0, y.data (k2));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	457 k2++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	458 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	459 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	460 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	461 retval.data (ry + j * nr) = f (x.data (k1), y.data (k2));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	462 k1++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	463 k2++;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	464 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	465 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	466 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	467 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	468
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	469 retval.maybe_compress (true);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	470 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	471 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	472 {
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	473 octave_idx_type nz = x.nnz () + y.nnz ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	474 retval = SparseMatrix (nr, nc, nz);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	475 octave_idx_type ii = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	476 retval.cidx (ii) = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	477 octave_idx_type k1 = 0, k2 = 0;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	478
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	479 for (octave_idx_type j = 0; j < nc; j++)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	480 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	481 while (k1 < x.cidx(j+1) && k2 < y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	482 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	483 OCTAVE_QUIT;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	484 double val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	485 octave_idx_type r;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	486 if (k1 >= x.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	487 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	488 r = y.ridx (k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	489 val = f (0.0, y.data (k2++));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	490 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	491 else if (k2 >= y.cidx(j+1))
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	492 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	493 r = x.ridx (k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	494 val = f (x.data (k1++), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	495 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	496 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	497 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	498 octave_idx_type rx = x.ridx(k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	499 octave_idx_type ry = y.ridx(k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	500
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	501 if (rx < ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	502 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	503 r = x.ridx (k1);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	504 val = f (x.data (k1++), 0.0);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	505 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	506 else if (rx > ry)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	507 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	508 r = y.ridx (k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	509 val = f (0.0, y.data (k2++));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	510 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	511 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	512 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	513 r = y.ridx (k2);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	514 val = f (x.data (k1++), y.data (k2++));
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	515 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	516 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	517 if (val != 0.0)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	518 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	519 retval.data (ii) = val;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	520 retval.ridx (ii++) = r;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	521 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	522 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	523 retval.cidx (j + 1) = ii;
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	524 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	525
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	526 retval.maybe_compress (false);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	527 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	528
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	529 return retval;
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	530 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	531
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	532 DEFUN (atan2, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	533 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	534 @deftypefn {Mapping Function} {} atan2 (@var{y}, @var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	535 Compute atan (@var{y} / @var{x}) for corresponding elements of @var{y}\n\
8347 fa78cb8d8a5c corrections for typos Brian Gough<bjg@network-theory.co.uk> parents: 8303 diff changeset	536 and @var{x}. The result is in the range -pi to pi.\n\
3439 3234a698073a [project @ 2000-01-14 09:51:14 by jwe] jwe parents: 3428 diff changeset	537 @end deftypefn")
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	538 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	539 octave_value retval;
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	540
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	541 int nargin = args.length ();
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	542
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	543 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	544 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	545 if (args(0).is_integer_type () \|\| args(1).is_integer_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	546 error ("atan2: not defined for integer types");
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	547 else
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	548 {
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	549 octave_value arg_y = args(0);
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	550 octave_value arg_x = args(1);
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	551
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	552 dim_vector y_dims = arg_y.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	553 dim_vector x_dims = arg_x.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	554
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	555 bool y_is_scalar = y_dims.all_ones ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	556 bool x_is_scalar = x_dims.all_ones ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	557
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	558 bool is_float = arg_y.is_single_type () \|\| arg_x.is_single_type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	559
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	560 if (y_is_scalar && x_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	561 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	562 if (is_float)
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	563 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	564 float y = arg_y.float_value ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	565
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	566 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	567 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	568 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	569
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	570 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	571 retval = atan2f (y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	572 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	573 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	574 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	575 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	576 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	577
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	578 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	579 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	580 double x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	581
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	582 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	583 retval = atan2 (y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	584 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	585 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	586 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	587 else if (y_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	588 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	589 if (is_float)
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	590 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	591 float y = arg_y.float_value ();
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	592
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	593 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	594 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	595 // Even if x is sparse return a full matrix here
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	596 FloatNDArray x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	597
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	598 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	599 retval = map_f_fm (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	600 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	601 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	602 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	603 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	604 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	605
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	606 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	607 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	608 // Even if x is sparse return a full matrix here
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	609 NDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	610
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	611 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	612 retval = map_d_m (atan2, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	613 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	614 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	615 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	616 else if (x_is_scalar)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	617 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	618 if (arg_y.is_sparse_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	619 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	620 SparseMatrix y = arg_y.sparse_matrix_value ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	621
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	622 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	623 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	624 double x = arg_x.double_value ();
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	625
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	626 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	627 retval = map_s_d (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	628 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	629 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	630 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	631 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	632 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	633
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	634 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	635 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	636 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	637
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	638 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	639 retval = map_fm_f (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	640 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	641 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	642 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	643 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	644 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	645
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	646 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	647 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	648 double x = arg_x.double_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	649
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	650 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	651 retval = map_m_d (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	652 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	653 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	654 }
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	655 else if (y_dims == x_dims)
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	656 {
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	657 // Even if y is sparse return a full matrix here
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	658 if (arg_x.is_sparse_type ())
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	659 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	660 SparseMatrix y = arg_y.sparse_matrix_value ();
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	661
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	662 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	663 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	664 SparseMatrix x = arg_x.sparse_matrix_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	665
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	666 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	667 retval = map_s_s (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	668 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	669 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	670 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	671 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	672 FloatNDArray y = arg_y.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	673
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	674 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	675 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	676 FloatNDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	677
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	678 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	679 retval = map_fm_fm (atan2f, y, x);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	680 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	681 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	682 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	683 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	684 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	685
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	686 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	687 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	688 NDArray x = arg_x.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	689
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	690 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	691 retval = map_m_m (atan2, y, x);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	692 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	693 }
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	694 }
7494 bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	695 else
bd2bd04e68ca Treat integer types for mod/rem correctly David Bateman <dbateman@free.fr> parents: 7433 diff changeset	696 error ("atan2: nonconformant matrices");
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	697 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	698 }
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	699 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	700 print_usage ();
649 1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	701
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	702 return retval;
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	703 }
1a674dba2e9e [project @ 1994-08-24 15:47:23 by jwe] jwe parents: 648 diff changeset	704
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	705 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	706 %!assert (size (atan2 (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	707 %!assert (size (atan2 (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	708 %!assert (size (atan2 (rand (2, 3, 4), 1)), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	709 %!assert (size (atan2 (1, rand (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	710 %!assert (size (atan2 (1, 2)), [1, 1])
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	711
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	712 %!test
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	713 %! rt2 = sqrt (2);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	714 %! rt3 = sqrt (3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	715 %! v = [0, pi/6, pi/4, pi/3, -pi/3, -pi/4, -pi/6, 0];
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	716 %! y = [0, rt3, 1, rt3, -rt3, -1, -rt3, 0];
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	717 %! x = [1, 3, 1, 1, 1, 1, 3, 1];
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	718 %! assert(atan2 (y, x), v, sqrt (eps));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	719
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	720 %!test
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	721 %! rt2 = sqrt (2);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	722 %! rt3 = sqrt (3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	723 %! v = single([0, pi/6, pi/4, pi/3, -pi/3, -pi/4, -pi/6, 0]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	724 %! y = single([0, rt3, 1, rt3, -rt3, -1, -rt3, 0]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	725 %! x = single([1, 3, 1, 1, 1, 1, 3, 1]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	726 %! assert(atan2 (y, x), v, sqrt (eps('single')));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	727
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	728 %!error <Invalid call to atan2.*> atan2 ();
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	729 %!error <Invalid call to atan2.*> atan2 (1, 2, 3);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	730
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	731 */
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	732
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	733
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	734
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	735 DEFUN (hypot, args, ,
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	736 "-- texinfo --\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	737 @deftypefn {Mapping Function} {} hypot (@var{x}, @var{y})\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	738 Compute square-root of the squares of @var{x} and @var{y}\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	739 element-by-element. This equivalent to @code{sqrt (@var{x}.^ 2 + @var{y}\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	740 .^ 2)}, but calculated in a manner that avoids overflows for large\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	741 values of @var{x} or @var{y}.\n\
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	742 @end deftypefn")
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	743 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	744 octave_value retval;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	745
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	746 int nargin = args.length ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	747
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	748 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	749 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	750 if (args(0).is_integer_type () \|\| args(1).is_integer_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	751 error ("hypot: not defined for integer types");
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	752 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	753 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	754 octave_value arg_x = args(0);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	755 octave_value arg_y = args(1);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	756
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	757 dim_vector x_dims = arg_x.dims ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	758 dim_vector y_dims = arg_y.dims ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	759
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	760 bool x_is_scalar = x_dims.all_ones ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	761 bool y_is_scalar = y_dims.all_ones ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	762
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	763 bool is_float = arg_y.is_single_type () \|\| arg_x.is_single_type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	764
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	765 if (y_is_scalar && x_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	766 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	767 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	768 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	769 float x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	770 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	771 x = abs (arg_x.float_complex_value ());
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	772 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	773 x = arg_x.float_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	774
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	775 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	776 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	777 float y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	778 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	779 y = abs (arg_y.float_complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	780 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	781 y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	782
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	783 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	784 retval = hypotf (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	785 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	786 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	787 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	788 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	789 double x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	790 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	791 x = abs (arg_x.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	792 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	793 x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	794
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	795 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	796 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	797 double y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	798 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	799 y = abs (arg_y.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	800 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	801 y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	802
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	803 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	804 retval = hypot (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	805 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	806 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	807 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	808 else if (y_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	809 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	810 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	811 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	812 FloatNDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	813 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	814 x = arg_x.float_complex_array_value ().abs ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	815 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	816 x = arg_x.float_array_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	817
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	818 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	819 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	820 float y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	821 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	822 y = abs (arg_y.float_complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	823 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	824 y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	825
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	826 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	827 retval = map_fm_f (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	828 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	829 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	830 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	831 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	832 NDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	833 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	834 x = arg_x.complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	835 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	836 x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	837
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	838 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	839 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	840 double y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	841 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	842 y = abs (arg_y.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	843 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	844 y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	845
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	846 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	847 retval = map_m_d (hypot, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	848 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	849 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	850 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	851 else if (x_is_scalar)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	852 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	853 if (is_float)
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	854 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	855 float x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	856 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	857 x = abs (arg_x.float_complex_value ());
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	858 else
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	859 x = arg_x.float_value ();
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	860
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	861 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	862 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	863 FloatNDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	864 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	865 y = arg_y.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	866 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	867 y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	868
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	869 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	870 retval = map_f_fm (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	871 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	872 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	873 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	874 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	875 double x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	876 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	877 x = abs (arg_x.complex_value ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	878 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	879 x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	880
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	881 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	882 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	883 NDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	884 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	885 y = arg_y.complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	886 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	887 y = arg_y.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	888
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	889 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	890 retval = map_d_m (hypot, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	891 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	892 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	893 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	894 else if (y_dims == x_dims)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	895 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	896 if (arg_x.is_sparse_type () && arg_y.is_sparse_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	897 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	898 SparseMatrix x;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	899 if (arg_x.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	900 x = arg_x.sparse_complex_matrix_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	901 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	902 x = arg_x.sparse_matrix_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	903
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	904 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	905 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	906 SparseMatrix y;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	907 if (arg_y.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	908 y = arg_y.sparse_complex_matrix_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	909 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	910 y = arg_y.sparse_matrix_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	911
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	912 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	913 retval = map_s_s (hypot, x, y);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	914 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	915 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	916 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	917 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	918 FloatNDArray x;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	919 if (arg_x.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	920 x = arg_x.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	921 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	922 x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	923
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	924 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	925 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	926 FloatNDArray y;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	927 if (arg_y.is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	928 y = arg_y.float_complex_array_value ().abs ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	929 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	930 y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	931
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	932 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	933 retval = map_fm_fm (hypotf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	934 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	935 }
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	936 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	937 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	938 NDArray x;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	939 if (arg_x.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	940 x = arg_x.complex_array_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	941 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	942 x = arg_x.array_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	943
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	944 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	945 {
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	946 NDArray y;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	947 if (arg_y.is_complex_type ())
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	948 y = arg_y.complex_array_value ().abs ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	949 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	950 y = arg_y.array_value ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	951
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	952 if (! error_state)
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	953 retval = map_m_m (hypot, x, y);
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	954 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	955 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	956 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	957 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	958 error ("hypot: nonconformant matrices");
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	959 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	960 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	961 else
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	962 print_usage ();
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	963
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	964 return retval;
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	965 }
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	966
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	967 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	968 %!assert (size (hypot (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	969 %!assert (size (hypot (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	970 %!assert (size (hypot (rand (2, 3, 4), 1)), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	971 %!assert (size (hypot (1, rand (2, 3, 4))), [2, 3, 4])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	972 %!assert (size (hypot (1, 2)), [1, 1])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	973 %!assert (hypot (1:10, 1:10), sqrt(2) * [1:10], 16*eps)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	974 %!assert (hypot (single(1:10), single(1:10)), single(sqrt(2) * [1:10]));
7631 b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	975 */
b2a5cda5c549 Add the hypot function David Bateman <dbateman@free.fr> parents: 7623 diff changeset	976
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	977 template<typename T, typename ET>
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	978 void
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	979 map_2_xlog2 (const Array<T>& x, Array<T>& f, Array<ET>& e)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	980 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	981 f = Array<T>(x.dims ());
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	982 e = Array<ET>(x.dims ());
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	983 for (octave_idx_type i = 0; i < x.numel (); i++)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	984 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	985 int exp;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	986 f.xelem (i) = xlog2 (x(i), exp);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	987 e.xelem (i) = exp;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	988 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	989 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	990
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	991 DEFUN (log2, args, nargout,
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	992 "-- texinfo --\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	993 @deftypefn {Mapping Function} {} log2 (@var{x})\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	994 @deftypefnx {Mapping Function} {[@var{f}, @var{e}] = } log2 (@var{x})\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	995 Compute the base-2 logarithm for each element of @var{x}.\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	996 If called with two output arguments, split @var{x} to\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	997 binary mantissa and exponent so that @code{1/2 <= abs(f) < 1} and\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	998 @var{e} is an integer. If @code{x = 0}, @code{f = e = 0}.\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	999 @seealso{log, log10, log2, exp}\n\
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1000 @end deftypefn")
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1001 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1002 octave_value_list retval;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1003
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1004 if (args.length () == 1)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1005 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1006 if (nargout < 2)
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1007 retval(0) = args(0).log2 ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1008 else if (args(0).is_single_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1009 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1010 if (args(0).is_real_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1011 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1012 FloatNDArray f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1013 FloatNDArray x = args(0).float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1014 // FIXME -- should E be an int value?
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1015 FloatMatrix e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1016 map_2_xlog2 (x, f, e);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1017 retval (1) = e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1018 retval (0) = f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1019 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1020 else if (args(0).is_complex_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1021 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1022 FloatComplexNDArray f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1023 FloatComplexNDArray x = args(0).float_complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1024 // FIXME -- should E be an int value?
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1025 FloatNDArray e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1026 map_2_xlog2 (x, f, e);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1027 retval (1) = e;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1028 retval (0) = f;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1029 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1030 }
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1031 else if (args(0).is_real_type ())
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1032 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1033 NDArray f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1034 NDArray x = args(0).array_value ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1035 // FIXME -- should E be an int value?
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1036 Matrix e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1037 map_2_xlog2 (x, f, e);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1038 retval (1) = e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1039 retval (0) = f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1040 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1041 else if (args(0).is_complex_type ())
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1042 {
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1043 ComplexNDArray f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1044 ComplexNDArray x = args(0).complex_array_value ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1045 // FIXME -- should E be an int value?
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1046 NDArray e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1047 map_2_xlog2 (x, f, e);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1048 retval (1) = e;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1049 retval (0) = f;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1050 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1051 else
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1052 gripe_wrong_type_arg ("log2", args(0));
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1053 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1054 else
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1055 print_usage ();
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1056
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1057 return retval;
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1058 }
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1059
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1060 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1061 %!assert(log2 ([1/4, 1/2, 1, 2, 4]), [-2, -1, 0, 1, 2]);
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1062 %!assert(log2(Inf), Inf);
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1063 %!assert(isnan(log2(NaN)));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1064 %!assert(log2(4i), 2 + log2(1i));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1065 %!assert(log2(complex(0,Inf)), Inf + log2(i));
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1066
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1067 %!test
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1068 %! [f, e] = log2 ([0,-1; 2,-4; Inf,-Inf]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1069 %! assert (f, [0,-0.5; 0.5,-0.5; Inf,-Inf]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1070 %! assert (e, [0,1;2,3;0,0])
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1071
7740 39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1072 %!test
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1073 %! [f, e] = log2 (complex (zeros (3, 2), [0,-1; 2,-4; Inf,-Inf]));
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1074 %! assert (f, complex (zeros (3, 2), [0,-0.5; 0.5,-0.5; Inf,-Inf]));
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1075 %! assert (e, [0,1; 2,3; 0,0]);
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1076 */
39930366b709 implement builtin log2 Jaroslav Hajek <highegg@gmail.com> parents: 7631 diff changeset	1077
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1078 DEFUN (fmod, args, ,
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1079 "-- texinfo --\n\
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1080 @deftypefn {Mapping Function} {} fmod (@var{x}, @var{y})\n\
4685 14a1c9f42f67 [project @ 2004-01-06 17:20:02 by jwe] jwe parents: 4593 diff changeset	1081 Compute the floating point remainder of dividing @var{x} by @var{y}\n\
14a1c9f42f67 [project @ 2004-01-06 17:20:02 by jwe] jwe parents: 4593 diff changeset	1082 using the C library function @code{fmod}. The result has the same\n\
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1083 sign as @var{x}. If @var{y} is zero, the result is implementation-defined.\n\
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1084 @end deftypefn")
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1085 {
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1086 octave_value retval;
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1087
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1088 int nargin = args.length ();
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1089
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1090 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1091 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1092 octave_value arg_y = args(0);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1093 octave_value arg_x = args(1);
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1094
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1095 dim_vector y_dims = arg_y.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1096 dim_vector x_dims = arg_x.dims ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1097
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1098 bool y_is_scalar = y_dims.all_ones ();
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1099 bool x_is_scalar = x_dims.all_ones ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1100
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1101 bool is_float = arg_y.is_single_type () \|\| arg_x.is_single_type ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1102
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1103 if (y_is_scalar && x_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1104 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1105 if (is_float)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1106 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1107 float y = arg_y.float_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1108
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1109 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1110 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1111 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1112
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1113 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1114 retval = fmod (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1115 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1116 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1117 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1118 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1119 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1120
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1121 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1122 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1123 double x = arg_x.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1124
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1125 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1126 retval = fmod (x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1127 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1128 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1129 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1130 else if (y_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1131 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1132 if (is_float)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1133 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1134 float y = arg_y.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1135
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1136 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1137 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1138 FloatNDArray x = arg_x.float_array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1139
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1140 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1141 retval = map_fm_f (fmodf, x, y);
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1142 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1143 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1144 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1145 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1146 double y = arg_y.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1147
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1148 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1149 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1150 if (arg_x.is_sparse_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1151 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1152 SparseMatrix x = arg_x.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1153
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1154 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1155 retval = map_s_d (fmod, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1156 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1157 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1158 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1159 NDArray x = arg_x.array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1160
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1161 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1162 retval = map_m_d (fmod, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1163 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1164 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1165 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1166 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1167 else if (x_is_scalar)
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1168 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1169 if (arg_y.is_sparse_type ())
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1170 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1171 SparseMatrix y = arg_y.sparse_matrix_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1172
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1173 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1174 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1175 double x = arg_x.double_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1176
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1177 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1178 retval = map_d_s (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1179 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1180 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1181 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1182 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1183 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1184
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1185 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1186 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1187 float x = arg_x.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1188
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1189 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1190 retval = map_f_fm (fmodf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1191 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1192 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1193 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1194 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1195 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1196
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1197 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1198 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1199 double x = arg_x.double_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1200
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1201 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1202 retval = map_d_m (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1203 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1204 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1205 }
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1206 else if (y_dims == x_dims)
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1207 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1208 if (arg_y.is_sparse_type () \|\| arg_x.is_sparse_type ())
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1209 {
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1210 SparseMatrix y = arg_y.sparse_matrix_value ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1211
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1212 if (! error_state)
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1213 {
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1214 SparseMatrix x = arg_x.sparse_matrix_value ();
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1215
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1216 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1217 retval = map_s_s (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1218 }
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1219 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1220 else if (is_float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1221 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1222 FloatNDArray y = arg_y.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1223
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1224 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1225 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1226 FloatNDArray x = arg_x.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1227
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1228 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1229 retval = map_fm_fm (fmodf, x, y);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1230 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1231 }
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1232 else
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1233 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1234 NDArray y = arg_y.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1235
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1236 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1237 {
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1238 NDArray x = arg_x.array_value ();
7505 f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1239
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1240 if (! error_state)
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1241 retval = map_m_m (fmod, x, y);
f5005d9510f4 Remove dispatched sparse functions and treat in the generic versions of the functions David Bateman <dbateman@free.fr> parents: 7494 diff changeset	1242 }
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1243 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1244 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1245 else
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1246 error ("fmod: nonconformant matrices");
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1247 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1248 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1249 print_usage ();
4311 a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1250
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1251 return retval;
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1252 }
a9e0bff33b02 [project @ 2003-01-30 04:11:58 by jwe] jwe parents: 4303 diff changeset	1253
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1254 /*
7741 72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1255 %!assert (size (fmod (zeros (0, 2), zeros (0, 2))), [0, 2])
72c0489653ac fix tests John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1256 %!assert (size (fmod (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4])
7743 fbe27e477578 more tests fixed John W. Eaton <jwe@octave.org> parents: 7741 diff changeset	1257 %!assert (size (fmod (rand (2, 3, 4), 1)), [2, 3, 4])
fbe27e477578 more tests fixed John W. Eaton <jwe@octave.org> parents: 7741 diff changeset	1258 %!assert (size (fmod (1, rand (2, 3, 4))), [2, 3, 4])
fbe27e477578 more tests fixed John W. Eaton <jwe@octave.org> parents: 7741 diff changeset	1259 %!assert (size (fmod (1, 2)), [1, 1])
7506 798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1260 */
798b0a00e80c atan2, fmod: accept N-d arrays John W. Eaton <jwe@octave.org> parents: 7505 diff changeset	1261
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1262 // FIXME Need to convert the reduction functions of this file for single precision
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1263
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1264 #define NATIVE_REDUCTION_1(FCN, TYPE, DIM) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1265 (arg.is_ ## TYPE ## _type ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1266 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1267 TYPE ## NDArray tmp = arg. TYPE ##_array_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1268 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1269 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1270 retval = tmp.FCN (DIM); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1271 }
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1272
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1273 #define NATIVE_REDUCTION(FCN) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1274 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1275 octave_value retval; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1276 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1277 int nargin = args.length (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1278 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1279 bool isnative = false; \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1280 bool isdouble = false; \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1281 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1282 if (nargin > 1 && args(nargin - 1).is_string ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1283 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1284 std::string str = args(nargin - 1).string_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1285 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1286 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1287 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1288 if (str == "native") \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1289 isnative = true; \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1290 else if (str == "double") \
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1291 isdouble = true; \
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1292 else \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1293 error ("sum: unrecognized string argument"); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1294 nargin --; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1295 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1296 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1297 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1298 if (nargin == 1 \|\| nargin == 2) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1299 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1300 octave_value arg = args(0); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1301 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1302 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1303 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1304 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1305 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1306 if (dim >= -1) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1307 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1308 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1309 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1310 if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1311 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1312 SparseMatrix tmp = arg.sparse_matrix_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1313 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1314 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1315 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1316 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1317 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1318 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1319 SparseComplexMatrix tmp = arg.sparse_complex_matrix_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1320 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1321 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1322 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1323 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1324 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1325 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1326 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1327 if (isnative) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1328 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1329 if NATIVE_REDUCTION_1 (FCN, uint8, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1330 else if NATIVE_REDUCTION_1 (FCN, uint16, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1331 else if NATIVE_REDUCTION_1 (FCN, uint32, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1332 else if NATIVE_REDUCTION_1 (FCN, uint64, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1333 else if NATIVE_REDUCTION_1 (FCN, int8, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1334 else if NATIVE_REDUCTION_1 (FCN, int16, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1335 else if NATIVE_REDUCTION_1 (FCN, int32, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1336 else if NATIVE_REDUCTION_1 (FCN, int64, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1337 else if NATIVE_REDUCTION_1 (FCN, bool, dim) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1338 else if (arg.is_char_matrix ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1339 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1340 error (#FCN, ": invalid char type"); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1341 } \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1342 else if (!isdouble && arg.is_single_type ()) \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1343 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1344 if (arg.is_complex_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1345 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1346 FloatComplexNDArray tmp = \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1347 arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1348 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1349 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1350 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1351 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1352 else if (arg.is_real_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1353 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1354 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1355 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1356 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1357 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1358 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1359 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1360 else if (arg.is_complex_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1361 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1362 ComplexNDArray tmp = arg.complex_array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1363 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1364 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1365 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1366 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1367 else if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1368 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1369 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1370 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1371 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1372 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1373 } \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1374 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1375 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1376 gripe_wrong_type_arg (#FCN, arg); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1377 return retval; \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1378 } \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1379 } \
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1380 else if (!isdouble && arg.is_single_type ()) \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1381 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1382 if (arg.is_real_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1383 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1384 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1385 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1386 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1387 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1388 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1389 else if (arg.is_complex_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1390 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1391 FloatComplexNDArray tmp = \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1392 arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1393 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1394 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1395 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1396 } \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1397 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1398 else if (arg.is_real_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1399 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1400 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1401 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1402 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1403 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1404 } \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1405 else if (arg.is_complex_type ()) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1406 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1407 ComplexNDArray tmp = arg.complex_array_value (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1408 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1409 if (! error_state) \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1410 retval = tmp.FCN (dim); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1411 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1412 else \
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1413 { \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1414 gripe_wrong_type_arg (#FCN, arg); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1415 return retval; \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1416 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1417 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1418 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1419 else \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1420 error (#FCN ": invalid dimension argument = %d", dim + 1); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1421 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1422 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1423 } \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1424 else \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1425 print_usage (); \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1426 \
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1427 return retval
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	1428
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1429 #define DATA_REDUCTION(FCN) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1430 \
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	1431 octave_value retval; \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1432 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1433 int nargin = args.length (); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1434 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1435 if (nargin == 1 \|\| nargin == 2) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1436 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1437 octave_value arg = args(0); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1438 \
3864 e78705239df5 [project @ 2001-11-16 12:56:20 by jwe] jwe parents: 3797 diff changeset	1439 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1440 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1441 if (! error_state) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1442 { \
4556 773a21e4fce8 [project @ 2003-10-28 05:02:10 by jwe] jwe parents: 4554 diff changeset	1443 if (dim >= -1) \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1444 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1445 if (arg.is_real_type ()) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1446 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1447 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1448 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1449 SparseMatrix tmp = arg.sparse_matrix_value (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1450 \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1451 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1452 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1453 } \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1454 else if (arg.is_single_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1455 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1456 FloatNDArray tmp = arg.float_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1457 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1458 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1459 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1460 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1461 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1462 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1463 NDArray tmp = arg.array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1464 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1465 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1466 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1467 } \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1468 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1469 else if (arg.is_complex_type ()) \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1470 { \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1471 if (arg.is_sparse_type ()) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1472 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1473 SparseComplexMatrix tmp = arg.sparse_complex_matrix_value (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1474 \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1475 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1476 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1477 } \
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1478 else if (arg.is_single_type ()) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1479 { \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1480 FloatComplexNDArray tmp = arg.float_complex_array_value (); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1481 \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1482 if (! error_state) \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1483 retval = tmp.FCN (dim); \
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	1484 } \
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1485 else \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1486 { \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1487 ComplexNDArray tmp = arg.complex_array_value (); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1488 \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1489 if (! error_state) \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1490 retval = tmp.FCN (dim); \
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7506 diff changeset	1491 } \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1492 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1493 else \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1494 { \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1495 gripe_wrong_type_arg (#FCN, arg); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1496 return retval; \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1497 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1498 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1499 else \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1500 error (#FCN ": invalid dimension argument = %d", dim + 1); \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1501 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1502 } \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1503 else \
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1504 print_usage (); \
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1505 \
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1506 return retval
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1507
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1508 DEFUN (cumprod, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1509 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1510 @deftypefn {Built-in Function} {} cumprod (@var{x}, @var{dim})\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1511 Cumulative product of elements along dimension @var{dim}. If\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1512 @var{dim} is omitted, it defaults to 1 (column-wise cumulative\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1513 products).\n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1514 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1515 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1516 return the cumulative product of the elements as a vector with the\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1517 same orientation as @var{x}.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1518 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1519 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1520 DATA_REDUCTION (cumprod);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1521 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1522
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1523 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1524
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1525 %!assert (cumprod ([1, 2, 3]), [1, 2, 6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1526 %!assert (cumprod ([-1; -2; -3]), [-1; 2; -6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1527 %!assert (cumprod ([i, 2+i, -3+2i, 4]), [i, -1+2i, -1-8i, -4-32i]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1528 %!assert (cumprod ([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i]), [1, 2, 3; i, 4i, 9i; -1+i, -8+8i, -27+27i]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1529
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1530 %!assert (cumprod (single([1, 2, 3])), single([1, 2, 6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1531 %!assert (cumprod (single([-1; -2; -3])), single([-1; 2; -6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1532 %!assert (cumprod (single([i, 2+i, -3+2i, 4])), single([i, -1+2i, -1-8i, -4-32i]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1533 %!assert (cumprod (single([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i])), single([1, 2, 3; i, 4i, 9i; -1+i, -8+8i, -27+27i]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1534
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1535 %!error <Invalid call to cumprod.*> cumprod ();
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1536
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1537 %!assert (cumprod ([2, 3; 4, 5], 1), [2, 3; 8, 15]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1538 %!assert (cumprod ([2, 3; 4, 5], 2), [2, 6; 4, 20]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1539
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1540 %!assert (cumprod (single([2, 3; 4, 5]), 1), single([2, 3; 8, 15]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1541 %!assert (cumprod (single([2, 3; 4, 5]), 2), single([2, 6; 4, 20]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1542
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1543 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1544
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1545 DEFUN (cumsum, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1546 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1547 @deftypefn {Built-in Function} {} cumsum (@var{x}, @var{dim})\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1548 Cumulative sum of elements along dimension @var{dim}. If @var{dim}\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1549 is omitted, it defaults to 1 (column-wise cumulative sums).\n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1550 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1551 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1552 return the cumulative sum of the elements as a vector with the\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1553 same orientation as @var{x}.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1554 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1555 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1556 DATA_REDUCTION (cumsum);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1557 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1558
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1559 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1560
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1561 %!assert (cumsum ([1, 2, 3]), [1, 3, 6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1562 %!assert (cumsum ([-1; -2; -3]), [-1; -3; -6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1563 %!assert (cumsum ([i, 2+i, -3+2i, 4]), [i, 2+2i, -1+4i, 3+4i]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1564 %!assert (cumsum ([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i]), [1, 2, 3; 1+i, 2+2i, 3+3i; 2+2i, 4+4i, 6+6i]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1565
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1566 %!assert (cumsum (single([1, 2, 3])), single([1, 3, 6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1567 %!assert (cumsum (single([-1; -2; -3])), single([-1; -3; -6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1568 %!assert (cumsum (single([i, 2+i, -3+2i, 4])), single([i, 2+2i, -1+4i, 3+4i]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1569 %!assert (cumsum (single([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i])), single([1, 2, 3; 1+i, 2+2i, 3+3i; 2+2i, 4+4i, 6+6i]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1570
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1571 %!error <Invalid call to cumsum.*> cumsum ();
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1572
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1573 %!assert (cumsum ([1, 2; 3, 4], 1), [1, 2; 4, 6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1574 %!assert (cumsum ([1, 2; 3, 4], 2), [1, 3; 3, 7]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1575
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1576 %!assert (cumsum (single([1, 2; 3, 4]), 1), single([1, 2; 4, 6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1577 %!assert (cumsum (single([1, 2; 3, 4]), 2), single([1, 3; 3, 7]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1578
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1579 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1580
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1581 DEFUN (diag, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1582 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1583 @deftypefn {Built-in Function} {} diag (@var{v}, @var{k})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1584 Return a diagonal matrix with vector @var{v} on diagonal @var{k}. The\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1585 second argument is optional. If it is positive, the vector is placed on\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1586 the @var{k}-th super-diagonal. If it is negative, it is placed on the\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1587 @var{-k}-th sub-diagonal. The default value of @var{k} is 0, and the\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1588 vector is placed on the main diagonal. For example,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1589 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1590 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1591 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1592 diag ([1, 2, 3], 1)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1593 @result{} 0 1 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1594 0 0 2 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1595 0 0 0 3\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1596 0 0 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1597 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1598 @end example\n\
6772 315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1599 \n\
315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1600 @noindent\n\
315bc7c8f9b5 [project @ 2007-07-10 09:51:39 by dbateman] dbateman parents: 6688 diff changeset	1601 Given a matrix argument, instead of a vector, @code{diag} extracts the\n\
6774 3b09c87d5165 [project @ 2007-07-13 13:27:36 by dbateman] dbateman parents: 6772 diff changeset	1602 @var{k}-th diagonal of the matrix.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	1603 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1604 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	1605 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1606
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1607 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1608
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	1609 if (nargin == 1 && args(0).is_defined ())
7620 36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1610 retval = args(0).diag();
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	1611 else if (nargin == 2 && args(0).is_defined () && args(1).is_defined ())
7620 36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1612 {
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1613 octave_idx_type k = args(1).int_value ();
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1614
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1615 if (error_state)
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1616 error ("diag: invalid second argument");
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1617 else
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1618 retval = args(0).diag(k);
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7618 diff changeset	1619 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1620 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1621 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1622
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1623 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1624 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1625
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1626 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1627
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1628 %!assert(diag ([1; 2; 3]), [1, 0, 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	1629 %!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	1630 %!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	1631 %!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	1632 %!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	1633
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1634 %!assert(diag ([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	1635 %!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	1636 %!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	1637
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1638 %!assert(diag (single([1; 2; 3])), single([1, 0, 0; 0, 2, 0; 0, 0, 3]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1639 %!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	1640 %!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	1641 %!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	1642 %!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	1643
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1644 %!assert(diag (single([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	1645 %!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	1646 %!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	1647
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1648 %!assert(diag (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	1649 %!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	1650 %!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	1651 %!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	1652 %!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	1653
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1654 %!assert(diag (int8([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	1655 %!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	1656 %!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	1657
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1658 %!error <Invalid call to diag.*> diag ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1659 %!error <Invalid call to diag.*> diag (1, 2, 3);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1660
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1661 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1662
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	1663 DEFUN (prod, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1664 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1665 @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	1666 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	1667 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	1668 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	1669 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	1670 return the product of the elements.\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	1671 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1672 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	1673 DATA_REDUCTION (prod);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1674 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	1675
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1676 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1677
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1678 %!assert (prod ([1, 2, 3]), 6);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1679 %!assert (prod ([-1; -2; -3]), -6);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1680 %!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	1681 %!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	1682
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1683 %!assert (prod (single([1, 2, 3])), single(6));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1684 %!assert (prod (single([-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	1685 %!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	1686 %!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	1687
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1688 %!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	1689
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1690 %!assert (prod ([1, 2; 3, 4], 1), [3, 8]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1691 %!assert (prod ([1, 2; 3, 4], 2), [2; 12]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1692 %!assert (prod (zeros (1, 0)), 1);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1693 %!assert (prod (zeros (1, 0), 1), zeros (1, 0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1694 %!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	1695 %!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	1696 %!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	1697 %!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	1698 %!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	1699 %!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	1700 %!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	1701 %!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	1702 %!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	1703 %!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	1704
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1705 %!assert (prod (single([1, 2; 3, 4]), 1), single([3, 8]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	1706 %!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	1707 %!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	1708 %!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	1709 %!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	1710 %!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	1711 %!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	1712 %!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	1713 %!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	1714 %!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	1715 %!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	1716 %!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	1717 %!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	1718 %!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	1719
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
8107 8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1722 #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	1723 do \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1724 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1725 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	1726 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	1727 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1728 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	1729 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1730 OCTAVE_QUIT; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1731 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1732 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	1733 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1734 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	1735 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1736 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	1737 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1738 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	1739 return retval; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1740 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1741 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	1742 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1743 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	1744 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1745 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	1746 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	1747 break; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1748 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1749 else \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1750 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	1751 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1752 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1753 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1754 while (0)
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1755
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1756 #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	1757 do \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1758 { \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1759 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	1760 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1761 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	1762 \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1763 retval = result; \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1764 } \
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1765 while (0)
8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1766
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1767 static octave_value
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1768 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	1769 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1770 octave_value retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1771
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1772 int n_args = args.length ();
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1773
5714 24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1774 if (n_args == 1)
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1775 retval = Matrix ();
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1776 else if (n_args == 2)
24f6a13878c2 [project @ 2006-03-23 21:46:09 by jwe] jwe parents: 5677 diff changeset	1777 retval = args(1);
5507 273612001e3a [project @ 2005-10-26 08:01:24 by dbateman] dbateman parents: 5476 diff changeset	1778 else if (n_args > 2)
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1779 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	1780 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	1781
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1782 if (error_state)
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1783 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1784 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	1785 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1786 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1787
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1788 if (dim >= 0)
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1789 {
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1790
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1791 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	1792 std::string result_type = args(1).class_name ();
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1793
8107 8655dc0906e6 Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 7991 diff changeset	1794 bool all_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	1795 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	1796 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	1797 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	1798
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1799 for (int i = 2; i < args.length (); i++)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1800 {
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1801 // 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	1802 // dimensions of the final array after concatenation.
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1803
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1804 if (! dv.concat (args(i).dims (), dim))
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1805 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1806 // Dimensions do not match.
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1807 error ("cat: dimension mismatch");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1808 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1809 }
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1810
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1811 result_type =
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1812 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	1813
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1814 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	1815 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	1816 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	1817 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	1818 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	1819 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	1820 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	1821 any_sparse_p = true;
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1822 }
4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1823
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1824 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	1825 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1826 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	1827 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1828 if (all_real_p)
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1829 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	1830 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1831 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	1832 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1833 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1834 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1835 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	1836 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	1837 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1838 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	1839 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1840 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1841 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	1842 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1843 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	1844 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	1845 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1846 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	1847 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	1848 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1849 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	1850 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1851 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	1852
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1853 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	1854
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1855 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	1856
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1857 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	1858
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1859 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	1860 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1861 else if (result_type == "logical")
5533 667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1862 {
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1863 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	1864 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	1865 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1866 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	1867 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1868 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	1869 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	1870 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	1871 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	1872 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	1873 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	1874 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	1875 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	1876 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	1877 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	1878 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	1879 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	1880 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	1881 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	1882 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	1883 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	1884 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1885 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1886 // 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	1887 // 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	1888 // 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	1889 // 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	1890 // 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	1891 // 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	1892 // 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	1893 //
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1894 // 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	1895 // 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	1896 // (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	1897 // 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	1898 // 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	1899
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1900 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	1901 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	1902
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1903 if (error_state)
c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1904 return retval;
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1905
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1906 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	1907 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	1908
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1909 for (int j = 1; j < n_args; j++)
6401 f8cbc0871ed6 [project @ 2007-03-09 15:34:45 by dbateman] dbateman parents: 6399 diff changeset	1910 {
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1911 // 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	1912 // 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	1913 // 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	1914 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	1915
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1916 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	1917 return retval;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1918
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1919 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	1920
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1921 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	1922 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1923 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	1924 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	1925 break;
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1926 }
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1927 else
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1928 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	1929 dv_tmp (dim) : 1);
6401 f8cbc0871ed6 [project @ 2007-03-09 15:34:45 by dbateman] dbateman parents: 6399 diff changeset	1930 }
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1931 retval = tmp;
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1932 }
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	1933
8113 38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1934 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	1935 {
38a797766a2a Special case single type conacation in Fcat. Rework cell2mat to take advantage David Bateman <dbateman@free.fr> parents: 8111 diff changeset	1936 // 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	1937 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	1938 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	1939 }
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1940 }
5533 667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1941 else
667ad2becb63 [project @ 2005-11-10 21:40:48 by jwe] jwe parents: 5507 diff changeset	1942 error ("%s: invalid dimension argument", fname.c_str ());
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1943 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1944 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	1945 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	1946
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1947 return retval;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1948 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1949
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1950 DEFUN (horzcat, args, ,
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1951 "-- texinfo --\n\
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1952 @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	1953 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	1954 @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	1955 @seealso{cat, vertcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	1956 @end deftypefn")
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1957 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1958 octave_value_list args_tmp = args;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1959
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1960 int dim = 2;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1961
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1962 octave_value d (dim);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1963
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1964 args_tmp.prepend (d);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1965
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1966 return do_cat (args_tmp, "horzcat");
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1967 }
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1968
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1969 DEFUN (vertcat, args, ,
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1970 "-- texinfo --\n\
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1971 @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	1972 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	1973 @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	1974 @seealso{cat, horzcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	1975 @end deftypefn")
4806 d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1976 {
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1977 octave_value_list args_tmp = args;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1978
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1979 int dim = 1;
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1980
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1981 octave_value d (dim);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1982
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1983 args_tmp.prepend (d);
d3bd9c04147f [project @ 2004-03-02 05:12:32 by jwe] jwe parents: 4768 diff changeset	1984
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	1985 return do_cat (args_tmp, "vertcat");
4806 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
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1988 DEFUN (cat, args, ,
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1989 "-- texinfo --\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1990 @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	1991 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	1992 @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	1993 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1994 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1995 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1996 A = ones (2, 2);\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1997 B = zeros (2, 2);\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1998 cat (2, A, B)\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	1999 @result{} ans =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2000 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2001 1 1 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2002 1 1 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2003 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2004 @end example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2005 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2006 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	2007 second dimension the following way:\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2008 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2009 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2010 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2011 [A, B].\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2012 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2013 @end example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2014 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2015 @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	2016 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	2017 following example shows:\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2018 @example\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2019 @group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2020 cat (4, ones(2, 2), zeros (2, 2))\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2021 @result{} ans =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2022 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2023 ans(:,:,1,1) =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2024 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2025 1 1\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2026 1 1\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2027 \n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2028 ans(:,:,1,2) =\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2029 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2030 0 0\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2031 @end group\n\
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2032 @end example\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2033 @seealso{horzcat, vertcat}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2034 @end deftypefn")
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2035 {
4824 4829055e154f [project @ 2004-03-08 18:16:04 by jwe] jwe parents: 4806 diff changeset	2036 return do_cat (args, "cat");
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2037 }
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4741 diff changeset	2038
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2039 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2040
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2041 %!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	2042 %! 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	2043 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2044 %! assert (cat (1, cast (1, t1), cast (2, 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	2045 %! 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	2046 %! 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	2047 %! 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	2048 %! 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	2049 %! 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	2050 %! 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	2051 %! 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	2052 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2053 %! assert ([cast(1, t1); cast(2, 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	2054 %! 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	2055 %! 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	2056 %! 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	2057 %! 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	2058 %! 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	2059 %! 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	2060 %! 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	2061 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2062 %! 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	2063 %! 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	2064 %! 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	2065 %! 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	2066 %! 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	2067 %! 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	2068 %! 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	2069 %! 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	2070 %! 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	2071 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2072 %! assert ([cast(1i, t1); cast(2, 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	2073 %! 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	2074 %! 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	2075 %! 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	2076 %! 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	2077 %! 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	2078 %! 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	2079 %! 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	2080 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2081 %! assert (cat (1, cast (1, t1), cast (2i, 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	2082 %! 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	2083 %! 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	2084 %! 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	2085 %! 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	2086 %! 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	2087 %! 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	2088 %! 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	2089 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2090 %! assert ([cast(1, t1); cast(2i, 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	2091 %! 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	2092 %! 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	2093 %! 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	2094 %! 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	2095 %! 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	2096 %! 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	2097 %! 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	2098 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2099 %! assert (cat (1, cast (1i, t1), cast (2i, 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	2100 %! 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	2101 %! 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	2102 %! 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	2103 %! 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	2104 %! 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	2105 %! 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	2106 %! 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	2107 %!
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2108 %! assert ([cast(1i, t1); cast(2i, 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	2109 %! 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	2110 %! 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	2111 %! 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	2112 %! 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	2113 %! 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	2114 %! 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	2115 %! 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	2116 %! endif
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2117 %! ret = true;
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 (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	2120 %!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	2121 %!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	2122 %!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	2123
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2124 %!assert (testcat('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	2125 %!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	2126 %!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	2127 %!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	2128 %!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	2129 %!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	2130 %!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	2131 %!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	2132 %!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	2133 %!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	2134 %!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	2135 %!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	2136 %!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	2137 %!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	2138 %!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	2139 %!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	2140 %!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	2141 %!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	2142 %!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	2143 %!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	2144
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2145 %!assert (testcat('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	2146 %!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	2147 %!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	2148 %!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	2149 %!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	2150 %!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	2151 %!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	2152 %!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	2153 %!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	2154 %!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	2155 %!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	2156 %!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	2157 %!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	2158 %!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	2159 %!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	2160 %!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	2161 %!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	2162 %!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	2163 %!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	2164 %!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	2165
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2166 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	2167
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2168 static octave_value
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2169 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	2170 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2171 octave_value retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2172
5148 9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2173 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	2174 {
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2175 Array<int> vec = args(1).int_vector_value ();
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2176
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	2177 // 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	2178 // here and pass that to permute?
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2179
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2180 int n = vec.length ();
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2181
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2182 for (int i = 0; i < n; i++)
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2183 vec(i)--;
9eab94f5fadf [project @ 2005-02-18 19:04:34 by jwe] jwe parents: 5061 diff changeset	2184
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2185 octave_value ret = args(0).permute (vec, inv);
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2186
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2187 if (! error_state)
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2188 retval = ret;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2189 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2190 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2191 print_usage ();
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2192
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2193 return retval;
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2194 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2195
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2196 DEFUN (permute, args, ,
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2197 "-- texinfo --\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2198 @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	2199 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	2200 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	2201 @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	2202 @seealso{ipermute}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2203 @end deftypefn")
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2204 {
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2205 return do_permute (args, false);
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2206 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2207
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2208 DEFUN (ipermute, args, ,
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2209 "-- texinfo --\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2210 @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	2211 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	2212 \n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2213 @example\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2214 ipermute (permute (a, perm), perm)\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2215 @end example\n\
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2216 returns the original array @var{a}.\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2217 @seealso{permute}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5607 diff changeset	2218 @end deftypefn")
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2219 {
6959 47f4f4e88166 [project @ 2007-10-04 20:43:32 by jwe] jwe parents: 6953 diff changeset	2220 return do_permute (args, true);
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2221 }
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4569 diff changeset	2222
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2223 DEFUN (length, args, ,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2224 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2225 @deftypefn {Built-in Function} {} length (@var{a})\n\
4176 b8ec44432831 [project @ 2002-11-13 02:49:14 by jwe] jwe parents: 4153 diff changeset	2226 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	2227 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	2228 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	2229 @end deftypefn")
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2230 {
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2231 octave_value retval;
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2232
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2233 if (args.length () == 1)
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2234 {
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2235 int len = args(0).length ();
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2236
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2237 if (! error_state)
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	2238 retval = len;
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2239 }
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2240 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2241 print_usage ();
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2242
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2243 return retval;
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2244 }
7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3186 diff changeset	2245
4554 78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2246 DEFUN (ndims, args, ,
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2247 "-- texinfo --\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2248 @deftypefn {Built-in Function} {} ndims (@var{a})\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2249 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	2250 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	2251 Trailing singleton dimensions are not counted.\n\
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2252 @end deftypefn")
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2253 {
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2254 octave_value retval;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2255
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2256 if (args.length () == 1)
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2257 {
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2258 int n_dims = args(0).ndims ();
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2259
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2260 if (! error_state)
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2261 retval = n_dims;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2262 }
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2263 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2264 print_usage ();
4554 78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2265
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2266 return retval;
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2267 }
78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4545 diff changeset	2268
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2269 DEFUN (numel, args, ,
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2270 "-- texinfo --\n\
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2271 @deftypefn {Built-in Function} {} numel (@var{a})\n\
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2272 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	2273 @seealso{size}\n\
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2274 @end deftypefn")
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2275 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2276 octave_value retval;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2277
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2278 if (args.length () == 1)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2279 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2280 int numel = args(0).numel ();
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2281
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2282 if (! error_state)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2283 {
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2284 if (numel < 0)
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2285 numel = 0;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2286
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2287 retval = numel;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2288 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2289 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2290 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2291 print_usage ();
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2292
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2293 return retval;
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2294 }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	2295
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2296 DEFUN (size, args, nargout,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2297 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2298 @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	2299 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	2300 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2301 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	2302 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	2303 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	2304 etc. For example,\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2305 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2306 @example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2307 @group\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2308 size ([1, 2; 3, 4; 5, 6])\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2309 @result{} [ 3, 2 ]\n\
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2310 \n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2311 [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	2312 @result{} nr = 3\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2313 @result{} nc = 2\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2314 @end group\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2315 @end example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2316 \n\
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2317 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	2318 corresponding dimension. For example\n\
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2319 \n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2320 @example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2321 size ([1, 2; 3, 4; 5, 6], 2)\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2322 @result{} 2\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2323 @end example\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2324 \n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2325 @noindent\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2326 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	2327 @seealso{numel}\n\
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	2328 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2329 {
2086 bfb775fb6fe8 [project @ 1996-04-25 05:55:19 by jwe] jwe parents: 1996 diff changeset	2330 octave_value_list retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2331
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2332 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2333
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2334 if (nargin == 1)
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2335 {
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2336 dim_vector dimensions = args(0).dims ();
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2337
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2338 int ndims = dimensions.length ();
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2339
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2340 Matrix m (1, ndims);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2341
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2342 if (nargout > 1)
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2343 {
5991 265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2344 for (int i = nargout-1; i >= ndims; i--)
265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2345 retval(i) = 1;
265723390e7b [project @ 2006-09-15 17:30:23 by jwe] jwe parents: 5823 diff changeset	2346
6197 c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2347 if (ndims > nargout)
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2348 {
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2349 octave_idx_type d = 1;
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2350
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2351 while (ndims >= nargout)
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2352 d *= dimensions(--ndims);
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2353
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2354 retval(ndims) = d;
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2355 }
c67c11e22828 [project @ 2006-12-04 16:08:30 by dbateman] dbateman parents: 6175 diff changeset	2356
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2357 while (ndims--)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2358 retval(ndims) = dimensions(ndims);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2359 }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2360 else
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2361 {
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2362 for (int i = 0; i < ndims; i++)
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2363 m(0, i) = dimensions(i);
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2364
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4512 diff changeset	2365 retval(0) = m;
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2366 }
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2367 }
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2368 else if (nargin == 2 && nargout < 2)
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2369 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	2370 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	2371
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2372 if (error_state)
59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2373 error ("size: expecting scalar as second argument");
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2374 else
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2375 {
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2376 dim_vector dv = args(0).dims ();
e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2377
4911 14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2378 if (nd > 0)
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2379 {
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2380 if (nd <= dv.length ())
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2381 retval(0) = dv(nd-1);
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2382 else
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2383 retval(0) = 1;
14027e0bafa4 [project @ 2004-07-22 19:58:06 by jwe] jwe parents: 4845 diff changeset	2384 }
1031 59f5eb2d5eb3 [project @ 1995-01-15 21:11:11 by jwe] jwe parents: 1009 diff changeset	2385 else
4741 e44d0ac643a5 [project @ 2004-02-05 21:57:50 by jwe] jwe parents: 4739 diff changeset	2386 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	2387 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2388 }
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	2389 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2390 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2391
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2392 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2393 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2394
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2395 DEFUN (size_equal, args, ,
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2396 "-- texinfo --\n\
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2397 @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	2398 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	2399 Trailing singleton dimensions are ignored.\n\
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2400 @seealso{size, numel}\n\
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2401 @end deftypefn")
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2402 {
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2403 octave_value retval;
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2404
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2405 int nargin = args.length ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2406
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2407 if (nargin >= 2)
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2408 {
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2409 retval = true;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2410
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2411 dim_vector a_dims = args(0).dims ();
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2412 a_dims.chop_trailing_singletons ();
6561 dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2413
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2414 for (int i = 1; i < nargin; ++i)
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2415 {
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2416 dim_vector b_dims = args(i).dims ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2417 b_dims.chop_trailing_singletons ();
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2418
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2419 if (a_dims != b_dims)
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2420 {
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2421 retval = false;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2422 break;
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2423 }
dc83c15d7149 [project @ 2007-04-23 16:58:17 by jwe] jwe parents: 6556 diff changeset	2424 }
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2425 }
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2426 else
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2427 print_usage ();
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2428
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2429 return retval;
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2430 }
a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2431
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2432 DEFUN (nnz, args, ,
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2433 "-- texinfo --\n\
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2434 @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	2435 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	2436 @seealso{sparse}\n\
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2437 @end deftypefn")
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2438 {
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2439 octave_value retval;
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2440
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2441 if (args.length () == 1)
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2442 retval = args(0).nnz ();
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2443 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2444 print_usage ();
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2445
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2446 return retval;
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2447 }
dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5533 diff changeset	2448
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2449 DEFUN (nzmax, args, ,
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2450 "-- texinfo --\n\
6156 a46f14cdbecd [project @ 2006-11-13 19:20:23 by jwe] jwe parents: 6133 diff changeset	2451 @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	2452 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	2453 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	2454 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	2455 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	2456 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	2457 @seealso{sparse, spalloc}\n\
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2458 @end deftypefn")
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2459 {
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2460 octave_value retval;
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2461
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2462 if (args.length() == 1)
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2463 retval = args(0).nzmax ();
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2464 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2465 print_usage ();
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2466
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2467 return retval;
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2468 }
2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	2469
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2470 DEFUN (rows, args, ,
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2471 "-- texinfo --\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2472 @deftypefn {Built-in Function} {} rows (@var{a})\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2473 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	2474 @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	2475 @end deftypefn")
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2476 {
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2477 octave_value retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2478
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2479 if (args.length () == 1)
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2480 retval = args(0).rows ();
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2481 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2482 print_usage ();
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2483
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2484 return retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2485 }
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2486
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2487 DEFUN (columns, args, ,
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2488 "-- texinfo --\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2489 @deftypefn {Built-in Function} {} columns (@var{a})\n\
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2490 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	2491 @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	2492 @end deftypefn")
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2493 {
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2494 octave_value retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2495
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2496 if (args.length () == 1)
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2497 retval = args(0).columns ();
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2498 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2499 print_usage ();
5677 a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2500
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2501 return retval;
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2502 }
a8f6903535c9 [project @ 2006-03-16 05:54:20 by jwe] jwe parents: 5642 diff changeset	2503
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2504 DEFUN (sum, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2505 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2506 @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	2507 @deftypefnx {Built-in Function} {} sum (@dots{}, 'native')\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2508 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	2509 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	2510 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2511 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	2512 return the sum of the elements.\n\
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2513 \n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2514 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	2515 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	2516 double type. For example\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2517 \n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2518 @example\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2519 sum ([true, true])\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2520 @result{} 2\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2521 sum ([true, true], 'native')\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2522 @result{} true\n\
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2523 @end example\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2524 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2525 {
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2526 NATIVE_REDUCTION (sum);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2527 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2528
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2529 /*
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2530
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2531 %!assert (sum([true,true]), 2)
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2532 %!assert (sum([true,true],'native'), true)
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2533 %!assert (sum(int8([127,10,-20])), 117);
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2534 %!assert (sum(int8([127,10,-20]),'native'), int8(107));
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2535
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2536 %!assert(sum ([1, 2, 3]), 6)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2537 %!assert(sum ([-1; -2; -3]), -6);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2538 %!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	2539 %!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	2540
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2541 %!assert(sum (single([1, 2, 3])), single(6))
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2542 %!assert(sum (single([-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	2543 %!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	2544 %!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	2545
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2546 %!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	2547
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2548 %!assert (sum ([1, 2; 3, 4], 1), [4, 6]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2549 %!assert (sum ([1, 2; 3, 4], 2), [3; 7]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2550 %!assert (sum (zeros (1, 0)), 0);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2551 %!assert (sum (zeros (1, 0), 1), zeros(1, 0));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2552 %!assert (sum (zeros (1, 0), 2), 0);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2553 %!assert (sum (zeros (0, 1)), 0);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2554 %!assert (sum (zeros (0, 1), 1), 0);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2555 %!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	2556 %!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	2557 %!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	2558 %!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	2559 %!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	2560 %!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	2561 %!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	2562 %!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	2563 %!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	2564 %!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	2565 %!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	2566 %!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	2567
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2568 %!assert (sum (single([1, 2; 3, 4]), 1), single([4, 6]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2569 %!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	2570 %!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	2571 %!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	2572 %!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	2573 %!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	2574 %!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	2575 %!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	2576 %!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	2577 %!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	2578 %!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	2579 %!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	2580 %!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	2581 %!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	2582 %!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	2583 %!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	2584 %!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	2585 %!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	2586 %!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	2587
7112 f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2588 */
f90a8188c9c2 [project @ 2007-11-07 00:24:11 by dbateman] dbateman parents: 7103 diff changeset	2589
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	2590 DEFUN (sumsq, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2591 "-- texinfo --\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2592 @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	2593 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	2594 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	2595 \n\
5061 4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2596 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	2597 return the sum of squares of the elements.\n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2598 \n\
4689ee5e88ec [project @ 2004-11-03 21:23:42 by jwe] jwe parents: 5058 diff changeset	2599 This function is conceptually equivalent to computing\n\
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2600 @example\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2601 sum (x .* conj (x), dim)\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2602 @end example\n\
4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2603 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	2604 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2605 {
3723 4c3774db5b3c [project @ 2000-10-12 05:10:08 by jwe] jwe parents: 3665 diff changeset	2606 DATA_REDUCTION (sumsq);
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2607 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	2608
7815 a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2609 /*
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2610
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2611 %!assert(sumsq ([1, 2, 3]), 14)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2612 %!assert(sumsq ([-1; -2; 4i]), 21);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2613 %!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	2614
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2615 %!assert(sumsq (single([1, 2, 3])), single(14))
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2616 %!assert(sumsq (single([-1; -2; 4i])), single(21));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2617 %!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	2618
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2619 %!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	2620
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2621 %!assert (sumsq ([1, 2; 3, 4], 1), [10, 20]);
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2622 %!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	2623
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2624 %!assert (sumsq (single([1, 2; 3, 4]), 1), single([10, 20]));
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2625 %!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	2626
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2627 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2628
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2629 DEFUN (islogical, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2630 "-- texinfo --\n\
7144 30c0533e39ae [project @ 2007-11-09 17:37:24 by jwe] jwe parents: 7112 diff changeset	2631 @deftypefn {Built-in Function} {} islogical (@var{x})\n\
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2632 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	2633 @end deftypefn")
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2634 {
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2635 octave_value retval;
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2636
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2637 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2638 retval = args(0).is_bool_type ();
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2639 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2640 print_usage ();
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2641
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2642 return retval;
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2643 }
fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 diff changeset	2644
6688 b26a8e0e42cd [project @ 2007-06-04 06:25:21 by jwe] jwe parents: 6671 diff changeset	2645 DEFALIAS (isbool, islogical);
3209 fbb332b96e4f [project @ 1998-11-03 20:48:54 by jwe] jwe parents: 3206 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 (islogical(true), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2650 %!assert (islogical(false), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2651 %!assert (islogical([true, false]), true)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2652 %!assert (islogical(1), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2653 %!assert (islogical(1i), false)
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2654 %!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	2655 %!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	2656 %!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	2657 %!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	2658
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2659 */
a41df65f3f00 Add some single precision test code and fix resulting bugs David Bateman <dbateman@free.fr> parents: 7814 diff changeset	2660
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2661 DEFUN (isinteger, args, ,
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2662 "-- texinfo --\n\
6230 06bee64edc08 [project @ 2007-01-08 16:59:35 by jwe] jwe parents: 6223 diff changeset	2663 @deftypefn {Built-in Function} {} isinteger (@var{x})\n\
6223 a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2664 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	2665 Note that @code{isinteger (14)} is false because numeric constants in\n\
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2666 are double precision floating point values.\n\
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2667 @seealso{isreal, isnumeric, class, isa}\n\
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2668 @end deftypefn")
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2669 {
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2670 octave_value retval;
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2671
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2672 if (args.length () == 1)
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2673 retval = args(0).is_integer_type ();
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2674 else
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2675 print_usage ();
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2676
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2677 return retval;
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2678 }
a6cc01dd09f9 [project @ 2007-01-03 20:59:28 by jwe] jwe parents: 6197 diff changeset	2679
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	2680 DEFUN (iscomplex, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2681 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	2682 @deftypefn {Built-in Function} {} iscomplex (@var{x})\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2683 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	2684 @end deftypefn")
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2685 {
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2686 octave_value retval;
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2687
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2688 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2689 retval = args(0).is_complex_type ();
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2690 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2691 print_usage ();
3186 edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2692
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2693 return retval;
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2694 }
edaa9a2d3d9c [project @ 1998-10-02 19:12:19 by jwe] jwe parents: 3174 diff changeset	2695
7576 7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2696 DEFUN (isfloat, args, ,
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2697 "-- texinfo --\n\
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2698 @deftypefn {Built-in Function} {} isfloat (@var{x})\n\
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2699 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	2700 @end deftypefn")
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2701 {
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2702 octave_value retval;
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2703
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2704 if (args.length () == 1)
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2705 retval = args(0).is_float_type ();
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2706 else
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2707 print_usage ();
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2708
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2709 return retval;
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2710 }
7ebdc99a0bab new isfloat function John W. Eaton <jwe@octave.org> parents: 7515 diff changeset	2711
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	2712 // FIXME -- perhaps this should be implemented with an
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2713 // octave_value member function?
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2714
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2715 DEFUN (complex, args, ,
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2716 "-- texinfo --\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2717 @deftypefn {Built-in Function} {} complex (@var{val})\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2718 @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	2719 Convert @var{x} to a complex value.\n\
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2720 @end deftypefn")
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2721 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2722 octave_value retval;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2723
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2724 int nargin = args.length ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2725
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2726 if (nargin == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2727 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2728 octave_value arg = args(0);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2729
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2730 if (arg.is_complex_type ())
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2731 retval = arg;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2732 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2733 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2734 if (arg.is_sparse_type ())
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2735 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2736 SparseComplexMatrix val = arg.sparse_complex_matrix_value ();
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2737
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2738 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2739 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	2740 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2741 else if (arg.is_single_type ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2742 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2743 if (arg.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2744 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2745 FloatComplex val = arg.float_complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2746
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2747 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2748 retval = octave_value (new octave_float_complex (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2749 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2750 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2751 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2752 FloatComplexNDArray val = arg.float_complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2753
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2754 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2755 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	2756 }
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2757 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2758 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2759 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2760 if (arg.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2761 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2762 Complex val = arg.complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2763
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2764 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2765 retval = octave_value (new octave_complex (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2766 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2767 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2768 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2769 ComplexNDArray val = arg.complex_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2770
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2771 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2772 retval = octave_value (new octave_complex_matrix (val));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2773 }
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2774 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2775
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2776 if (error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2777 error ("complex: invalid conversion");
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2778 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2779 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2780 else if (nargin == 2)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2781 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2782 octave_value re = args(0);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2783 octave_value im = args(1);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2784
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2785 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	2786 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2787 const SparseMatrix re_val = re.sparse_matrix_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2788 const SparseMatrix im_val = im.sparse_matrix_value ();
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 if (!error_state)
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 (re.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2793 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2794 SparseComplexMatrix result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2795 if (re_val.nnz () == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2796 result = Complex(0, 1) * SparseComplexMatrix (im_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2797 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2798 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2799 result = SparseComplexMatrix (im_val.dims (), re_val (0));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2800 octave_idx_type nr = im_val.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2801 octave_idx_type nc = im_val.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2802
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2803 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	2804 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2805 octave_idx_type off = j * nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2806 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	2807 i < im_val.cidx(j + 1); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2808 result.data (im_val.ridx(i) + off) =
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2809 result.data (im_val.ridx(i) + off) +
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2810 Complex (0, im_val.data (i));
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2811 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2812 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2813 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	2814 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2815 else if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2816 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2817 SparseComplexMatrix result;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2818 if (im_val.nnz () == 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2819 result = SparseComplexMatrix (re_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2820 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2821 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2822 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	2823 octave_idx_type nr = re_val.rows ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2824 octave_idx_type nc = re_val.cols ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2825
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2826 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	2827 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2828 octave_idx_type off = j * nr;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2829 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	2830 i < re_val.cidx(j + 1); i++)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2831 result.data (re_val.ridx(i) + off) =
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2832 result.data (re_val.ridx(i) + off) +
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2833 re_val.data (i);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2834 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2835 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2836 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	2837 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2838 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2839 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2840 if (re_val.dims () == im_val.dims ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2841 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2842 SparseComplexMatrix result = SparseComplexMatrix(re_val)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2843 + Complex(0, 1) * SparseComplexMatrix (im_val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2844 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	2845 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2846 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2847 error ("complex: dimension mismatch");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2848 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2849 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2850 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2851 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	2852 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2853 if (re.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 float re_val = re.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2856
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2857 if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2858 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2859 float im_val = im.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2860
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2861 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2862 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	2863 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2864 else
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 const FloatNDArray im_val = im.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2867
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2868 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2869 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2870 FloatComplexNDArray result (im_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2871
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2872 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	2873 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	2874
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2875 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	2876 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2877 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2878 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2879 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2880 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2881 const FloatNDArray re_val = re.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2882
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2883 if (im.numel () == 1)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2884 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2885 float im_val = im.float_value ();
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 if (! error_state)
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 FloatComplexNDArray result (re_val.dims (), FloatComplex ());
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 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	2892 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	2893
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2894 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	2895 }
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 else
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 const FloatNDArray im_val = im.float_array_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2900
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2901 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2902 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2903 if (re_val.dims () == im_val.dims ())
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2904 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2905 FloatComplexNDArray result (re_val.dims (), FloatComplex ());
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2906
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2907 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	2908 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	2909
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2910 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	2911 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2912 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2913 error ("complex: dimension mismatch");
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 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	2918 else if (re.numel () == 1)
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2919 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2920 double re_val = re.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2921
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2922 if (im.numel () == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2923 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2924 double im_val = im.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2925
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2926 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2927 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	2928 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2929 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2930 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2931 const NDArray im_val = im.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2932
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2933 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2934 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2935 ComplexNDArray result (im_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2936
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2937 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	2938 result.xelem (i) = Complex (re_val, im_val(i));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2939
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2940 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2941 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2942 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2943 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2944 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2945 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2946 const NDArray re_val = re.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2947
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2948 if (im.numel () == 1)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2949 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2950 double im_val = im.double_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2951
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2952 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2953 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2954 ComplexNDArray result (re_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2955
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2956 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	2957 result.xelem (i) = Complex (re_val(i), im_val);
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2958
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2959 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2960 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2961 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2962 else
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 const NDArray im_val = im.array_value ();
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2965
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2966 if (! error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2967 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2968 if (re_val.dims () == im_val.dims ())
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2969 {
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2970 ComplexNDArray result (re_val.dims (), Complex ());
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2971
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2972 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	2973 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	2974
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2975 retval = octave_value (new octave_complex_matrix (result));
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2976 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2977 else
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2978 error ("complex: dimension mismatch");
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
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2983 if (error_state)
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2984 error ("complex: invalid conversion");
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 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	2987 print_usage ();
5476 941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2988
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2989 return retval;
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2990 }
941f0fc6b596 [project @ 2005-09-29 22:46:07 by jwe] jwe parents: 5333 diff changeset	2991
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2992 DEFUN (isreal, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2993 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2994 @deftypefn {Built-in Function} {} isreal (@var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	2995 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	2996 @end deftypefn")
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2997 {
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2998 octave_value retval;
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	2999
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3000 if (args.length () == 1)
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3001 retval = args(0).is_real_type ();
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3002 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3003 print_usage ();
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3004
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3005 return retval;
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3006 }
4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3007
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3008 DEFUN (isempty, args, ,
3373 36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3009 "-- texinfo --\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3010 @deftypefn {Built-in Function} {} isempty (@var{a})\n\
36405da8e173 [project @ 1999-11-23 20:54:17 by jwe] jwe parents: 3369 diff changeset	3011 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	3012 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	3013 @end deftypefn")
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3014 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3015 octave_value retval = false;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3016
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3017 if (args.length () == 1)
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4556 diff changeset	3018 retval = args(0).is_empty ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3019 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3020 print_usage ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3021
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3022 return retval;
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3023 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3024
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3025 DEFUN (isnumeric, args, ,
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3026 "-- texinfo --\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3027 @deftypefn {Built-in Function} {} isnumeric (@var{x})\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3028 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	3029 @end deftypefn")
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3030 {
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3031 octave_value retval;
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3032
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3033 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3034 retval = args(0).is_numeric_type ();
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3035 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3036 print_usage ();
3206 d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3037
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3038 return retval;
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3039 }
d0d2b69dc6c2 [project @ 1998-11-03 02:43:31 by jwe] jwe parents: 3204 diff changeset	3040
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3041 DEFUN (islist, args, ,
3526 cc21933776a1 [project @ 2000-02-02 10:53:27 by jwe] jwe parents: 3523 diff changeset	3042 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3043 @deftypefn {Built-in Function} {} islist (@var{x})\n\
3428 5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3044 Return nonzero if @var{x} is a list.\n\
5b77cf82393c [project @ 2000-01-14 02:54:53 by jwe] jwe parents: 3418 diff changeset	3045 @end deftypefn")
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3046 {
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3047 octave_value retval;
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3048
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3049 if (args.length () == 1)
3258 4964d5391acc [project @ 1999-07-21 21:51:33 by jwe] jwe parents: 3238 diff changeset	3050 retval = args(0).is_list ();
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3051 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3052 print_usage ();
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3053
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3054 return retval;
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3055 }
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3202 diff changeset	3056
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3057 DEFUN (ismatrix, args, ,
3321 6923abb04e16 [project @ 1999-10-26 18:15:30 by jwe] jwe parents: 3307 diff changeset	3058 "-- texinfo --\n\
4028 ef75c970c8f5 [project @ 2002-08-09 07:19:02 by jwe] jwe parents: 4025 diff changeset	3059 @deftypefn {Built-in Function} {} ismatrix (@var{a})\n\
3321 6923abb04e16 [project @ 1999-10-26 18:15:30 by jwe] jwe parents: 3307 diff changeset	3060 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	3061 @end deftypefn")
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3062 {
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3063 octave_value retval = false;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3064
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3065 if (args.length () == 1)
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3066 {
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3067 octave_value arg = args(0);
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3068
3212 bf61c443a366 [project @ 1998-11-05 04:24:45 by jwe] jwe parents: 3209 diff changeset	3069 if (arg.is_scalar_type () \|\| arg.is_range ())
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3070 retval = true;
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3071 else if (arg.is_matrix_type ())
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4176 diff changeset	3072 retval = (arg.rows () >= 1 && arg.columns () >= 1);
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3073 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3074 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	3075 print_usage ();
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3076
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3077 return retval;
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3078 }
44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	3079
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3080 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3081
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3082 %!assert(ismatrix (1));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3083 %!assert(ismatrix ([1, 2, 3]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3084 %!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	3085
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3086 %% 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	3087 %!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	3088
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3089 %!assert(ismatrix (single(1)));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3090 %!assert(ismatrix (single([1, 2, 3])));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3091 %!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	3092
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3093 %% 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	3094 %!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	3095
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3096 %!assert(ismatrix ("t"), false);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3097 %!assert(ismatrix ("test"), false);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3098 %!assert(ismatrix (["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	3099
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3100 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3101 %! 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	3102 %! 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	3103
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3104 %!error <Invalid call to ismatrix.*> ismatrix ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3105 %!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	3106
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3107 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3108
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3109 static octave_value
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3110 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	3111 {
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3112 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3113
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3114 int nargin = args.length ();
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3115
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3116 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	3117
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3118 dim_vector dims (1, 1);
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3119
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3120 if (nargin > 0 && args(nargin-1).is_string ())
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3121 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3122 std::string nm = args(nargin-1).string_value ();
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3123 nargin--;
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3124
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3125 dt = oct_data_conv::string_to_data_type (nm);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3126
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3127 if (error_state)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3128 return retval;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3129 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3130
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3131 switch (nargin)
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3132 {
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	3133 case 0:
36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	3134 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3135
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	3136 case 1:
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3137 get_dimensions (args(0), fcn, dims);
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	3138 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3139
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3140 default:
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3141 {
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3142 dims.resize (nargin);
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3143
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3144 for (int i = 0; i < nargin; i++)
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3145 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3146 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	3147
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3148 if (error_state)
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3149 {
4732 b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	3150 error ("%s: expecting scalar integer arguments", fcn);
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3151 break;
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3152 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3153 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3154 }
742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	3155 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3156 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3157
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3158 if (! error_state)
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 dims.chop_trailing_singletons ();
4565 1db951a4fcd5 [project @ 2003-10-29 13:49:30 by jwe] jwe parents: 4563 diff changeset	3161
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3162 check_dimensions (dims, fcn);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3163
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	3164 // FIXME -- perhaps this should be made extensible by
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3165 // 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	3166 // the new value.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3167
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3168 // Note that automatic narrowing will handle conversion from
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3169 // NDArray to scalar.
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3170
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3171 if (! error_state)
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3172 {
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3173 switch (dt)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3174 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3175 case oct_data_conv::dt_int8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3176 retval = int8NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3177 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3178
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3179 case oct_data_conv::dt_uint8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3180 retval = uint8NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3181 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3182
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3183 case oct_data_conv::dt_int16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3184 retval = int16NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3185 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3186
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3187 case oct_data_conv::dt_uint16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3188 retval = uint16NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3189 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3190
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3191 case oct_data_conv::dt_int32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3192 retval = int32NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3193 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	3194
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3195 case oct_data_conv::dt_uint32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3196 retval = uint32NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3197 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3198
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3199 case oct_data_conv::dt_int64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3200 retval = int64NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3201 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3202
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3203 case oct_data_conv::dt_uint64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3204 retval = uint64NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3205 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3206
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3207 case oct_data_conv::dt_single:
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3208 retval = FloatNDArray (dims, val);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3209 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3210
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3211 case oct_data_conv::dt_double:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3212 retval = NDArray (dims, val);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3213 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3214
4986 fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3215 case oct_data_conv::dt_logical:
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3216 retval = boolNDArray (dims, val);
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3217 break;
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	3218
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3219 default:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3220 error ("%s: invalid class name", fcn);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3221 break;
4481 cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3222 }
cfbaee1f562f [project @ 2003-08-06 13:56:07 by jwe] jwe parents: 4479 diff changeset	3223 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3224 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3225
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3226 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3227 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3228
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3229 static octave_value
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3230 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	3231 const char *fcn)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3232 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3233 octave_value retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3234
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3235 int nargin = args.length ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3236
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3237 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	3238
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3239 dim_vector dims (1, 1);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3240
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3241 if (nargin > 0 && args(nargin-1).is_string ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3242 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3243 std::string nm = args(nargin-1).string_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3244 nargin--;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3245
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3246 dt = oct_data_conv::string_to_data_type (nm);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3247
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3248 if (error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3249 return retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3250 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3251
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3252 switch (nargin)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3253 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3254 case 0:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3255 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3256
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3257 case 1:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3258 get_dimensions (args(0), fcn, dims);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3259 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3260
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3261 default:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3262 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3263 dims.resize (nargin);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3264
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3265 for (int i = 0; i < nargin; i++)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3266 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3267 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	3268
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3269 if (error_state)
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 error ("%s: expecting scalar integer arguments", fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3272 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3273 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3274 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3275 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3276 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3277 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3278
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3279 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3280 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3281 dims.chop_trailing_singletons ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3282
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3283 check_dimensions (dims, fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3284
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3285 // Note that automatic narrowing will handle conversion from
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3286 // NDArray to scalar.
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3287
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3288 if (! error_state)
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 (dt)
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 oct_data_conv::dt_single:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3293 retval = FloatNDArray (dims, fval);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3294 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3295
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3296 case oct_data_conv::dt_double:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3297 retval = NDArray (dims, val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3298 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3299
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3300 default:
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3301 error ("%s: invalid class name", fcn);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3302 break;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3303 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3304 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3305 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3306
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3307 return retval;
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
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3310 static octave_value
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3311 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	3312 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3313 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3314
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3315 int nargin = args.length ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3316
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3317 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	3318
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3319 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3320
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3321 if (nargin > 0 && args(nargin-1).is_string ())
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3322 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3323 std::string nm = args(nargin-1).string_value ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3324 nargin--;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3325
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3326 dt = oct_data_conv::string_to_data_type (nm);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3327
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3328 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3329 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3330 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3331
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3332 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3333 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3334 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3335 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3336
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3337 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3338 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3339 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3340
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3341 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3342 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3343 dims.resize (nargin);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3344
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3345 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3346 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3347 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	3348
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3349 if (error_state)
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 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3352 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3353 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3354 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3355 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3356 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3357 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3358
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3359 if (! error_state)
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 dims.chop_trailing_singletons ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3362
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3363 check_dimensions (dims, fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3364
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3365 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3366 // NDArray to scalar.
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3367
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3368 if (! error_state)
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 (dt)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3371 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3372 case oct_data_conv::dt_single:
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3373 retval = FloatNDArray (dims, static_cast <float> (val));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3374 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3375
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3376 case oct_data_conv::dt_double:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3377 retval = NDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3378 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3379
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3380 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3381 error ("%s: invalid class name", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3382 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3383 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3384 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3385 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3386
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3387 return retval;
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
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3390 static octave_value
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3391 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	3392 const char *fcn)
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 octave_value retval;
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 int nargin = args.length ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3397
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3398 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	3399
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3400 dim_vector dims (1, 1);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3401
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3402 if (nargin > 0 && args(nargin-1).is_string ())
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3403 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3404 std::string nm = args(nargin-1).string_value ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3405 nargin--;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3406
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3407 dt = oct_data_conv::string_to_data_type (nm);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3408
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3409 if (error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3410 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3411 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3412
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3413 switch (nargin)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3414 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3415 case 0:
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 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3419 get_dimensions (args(0), fcn, dims);
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 default:
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 dims.resize (nargin);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3425
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3426 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3427 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3428 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	3429
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3430 if (error_state)
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 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3433 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3434 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3435 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3436 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3437 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3438 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3439
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3440 if (! error_state)
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 dims.chop_trailing_singletons ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3443
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3444 check_dimensions (dims, fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3445
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3446 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3447 // NDArray to scalar.
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3448
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3449 if (! error_state)
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 (dt)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3452 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3453 case oct_data_conv::dt_single:
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3454 retval = FloatComplexNDArray (dims, static_cast<FloatComplex> (val));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3455 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	3456
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3457 case oct_data_conv::dt_double:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3458 retval = ComplexNDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3459 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3460
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3461 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3462 error ("%s: invalid class name", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3463 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3464 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3465 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3466 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3467
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3468 return retval;
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
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3471 static octave_value
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3472 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	3473 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3474 octave_value retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3475
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3476 int nargin = args.length ();
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 dim_vector dims (1, 1);
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 switch (nargin)
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 case 0:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3483 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3484
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3485 case 1:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3486 get_dimensions (args(0), fcn, dims);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3487 break;
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 default:
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3490 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3491 dims.resize (nargin);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3492
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3493 for (int i = 0; i < nargin; i++)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3494 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	3495 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	3496
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3497 if (error_state)
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 error ("%s: expecting scalar integer arguments", fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3500 break;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3501 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3502 }
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 break;
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
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3507 if (! error_state)
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 dims.chop_trailing_singletons ();
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3510
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3511 check_dimensions (dims, fcn);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3512
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3513 // Note that automatic narrowing will handle conversion from
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3514 // NDArray to scalar.
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 if (! error_state)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3517 retval = boolNDArray (dims, val);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3518 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3519
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3520 return retval;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3521 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3522
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3523 DEFUN (ones, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3524 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3525 @deftypefn {Built-in Function} {} ones (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3526 @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	3527 @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	3528 @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	3529 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	3530 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	3531 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3532 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	3533 use an expression like\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3534 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3535 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3536 val_matrix = val * ones (n, m)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3537 @end example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3538 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3539 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	3540 the specified type, for example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3541 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3542 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3543 val = ones (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3544 @end example\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3545 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3546 {
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3547 return fill_matrix (args, 1, "ones");
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3548 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3549
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3550 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3551
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3552 %!assert(ones (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	3553 %!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	3554 %!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	3555 %!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	3556
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3557 %!assert(ones (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	3558 %!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	3559 %!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	3560 %!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	3561
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3562 %!assert(ones (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	3563 %!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	3564 %!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	3565 %!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	3566
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3567 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3568
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3569 DEFUN (zeros, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3570 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3571 @deftypefn {Built-in Function} {} zeros (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3572 @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	3573 @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	3574 @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	3575 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	3576 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	3577 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3578 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	3579 the specified type, for example\n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3580 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3581 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3582 val = zeros (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	3583 @end example\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	3584 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3585 {
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3586 return fill_matrix (args, 0, "zeros");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3587 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3588
7814 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
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3591 %!assert(zeros (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	3592 %!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	3593 %!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	3594 %!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	3595
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3596 %!assert(zeros (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	3597 %!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	3598 %!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	3599 %!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	3600
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3601 %!assert(zeros (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	3602 %!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	3603 %!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	3604 %!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	3605
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3606 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3607
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3608 DEFUN (Inf, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3609 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3610 @deftypefn {Built-in Function} {} Inf (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3611 @deftypefnx {Built-in Function} {} Inf (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3612 @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	3613 @deftypefnx {Built-in Function} {} Inf (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3614 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	3615 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	3616 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	3617 @samp{\"double\"}. The default is @samp{\"double\"}.\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3618 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3619 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3620 return fill_matrix (args, lo_ieee_inf_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3621 lo_ieee_float_inf_value (), "Inf");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3622 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3623
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3624 DEFALIAS (inf, Inf);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3625
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3626 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3627
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3628 %!assert(inf (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	3629 %!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	3630 %!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	3631 %!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	3632
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3633 %!assert(inf (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	3634 %!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	3635 %!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	3636 %!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	3637
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3638 %!error(inf (3,'int8'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3639 %!error(inf (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	3640 %!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	3641 %!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	3642
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
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3645 DEFUN (NaN, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3646 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3647 @deftypefn {Built-in Function} {} NaN (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3648 @deftypefnx {Built-in Function} {} NaN (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3649 @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	3650 @deftypefnx {Built-in Function} {} NaN (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3651 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	3652 (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	3653 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3654 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3655 $0/0$, or $\\infty - \\infty$,\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3656 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3657 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3658 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3659 0/0, or @samp{Inf - Inf},\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3660 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3661 or any operation with a NaN.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3662 \n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3663 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	3664 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	3665 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	3666 \n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3667 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	3668 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	3669 @samp{\"double\"}. The default is @samp{\"double\"}.\n\
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3670 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3671 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3672 return fill_matrix (args, lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3673 lo_ieee_float_nan_value (), "NaN");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3674 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3675
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3676 DEFALIAS (nan, NaN);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3677
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3678 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3679 %!assert(NaN (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	3680 %!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	3681 %!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	3682 %!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	3683
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3684 %!assert(NaN (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	3685 %!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	3686 %!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	3687 %!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	3688
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3689 %!error(NaN (3,'int8'));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3690 %!error(NaN (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	3691 %!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	3692 %!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	3693
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3694 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	3695
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3696 DEFUN (e, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3697 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3698 @deftypefn {Built-in Function} {} e (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3699 @deftypefnx {Built-in Function} {} e (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3700 @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	3701 @deftypefnx {Built-in Function} {} e (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3702 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	3703 to the base of natural logarithms. The constant\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3704 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3705 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3706 $e$\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3707 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3708 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3709 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3710 @var{e}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3711 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3712 satisfies the equation\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3713 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3714 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3715 $\\log (e) = 1$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3716 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3717 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3718 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3719 @code{log} (@var{e}) = 1.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3720 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3721 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3722 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3723 #if defined (M_E)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3724 double e_val = M_E;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3725 #else
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3726 double e_val = exp (1.0);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3727 #endif
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3728
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3729 return fill_matrix (args, e_val, "e");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3730 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3731
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3732 DEFUN (eps, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3733 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3734 @deftypefn {Built-in Function} {} eps (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3735 @deftypefnx {Built-in Function} {} eps (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3736 @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	3737 @deftypefnx {Built-in Function} {} eps (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3738 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	3739 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	3740 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	3741 floating point system. This number is obviously system-dependent. On\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3742 machines that support 64 bit IEEE floating point arithmetic, @code{eps}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3743 is approximately\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3744 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3745 2.2204e-16.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3746 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3747 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3748 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3749 $2.2204\\times10^{-16}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3750 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3751 @end iftex\n\
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3752 for double precision and\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3753 @ifinfo\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3754 1.1921e-07.\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3755 @end ifinfo\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3756 @iftex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3757 @tex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3758 $1.1921\\times10^{-7}$.\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3759 @end tex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3760 @end iftex\n\
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3761 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	3762 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	3763 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3764 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3765 int nargin = args.length ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3766 octave_value retval;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3767
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3768 if (nargin == 1 && ! args(0).is_string ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3769 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3770 if (args(0).is_single_type ())
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3771 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3772 float val = args(0).float_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3773
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3774 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3775 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3776 val = ::fabsf(val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3777 if (xisnan (val) \|\| xisinf (val))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3778 retval = fill_matrix (octave_value ("single"),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3779 lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3780 lo_ieee_float_nan_value (), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3781 else if (val < FLT_MIN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3782 retval = fill_matrix (octave_value ("single"), 0e0,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3783 powf (2.0, -149e0), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3784 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3785 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3786 int expon;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3787 frexpf (val, &expon);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3788 val = std::pow (static_cast <float> (2.0),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3789 static_cast <float> (expon - 24));
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3790 retval = fill_matrix (octave_value ("single"), DBL_EPSILON,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3791 val, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3792 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3793 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3794 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3795 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3796 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3797 double val = args(0).double_value ();
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3798
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3799 if (! error_state)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3800 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3801 val = ::fabs(val);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3802 if (xisnan (val) \|\| xisinf (val))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3803 retval = fill_matrix (octave_value_list (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3804 lo_ieee_nan_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3805 lo_ieee_float_nan_value (), "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3806 else if (val < DBL_MIN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3807 retval = fill_matrix (octave_value_list (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3808 pow (2.0, -1074e0), 0e0, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3809 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3810 {
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3811 int expon;
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3812 frexp (val, &expon);
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3813 val = std::pow (static_cast <double> (2.0),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3814 static_cast <double> (expon - 53));
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3815 retval = fill_matrix (octave_value_list (), val,
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3816 FLT_EPSILON, "eps");
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3817 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3818 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3819 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3820 }
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3821 else
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3822 retval = fill_matrix (args, DBL_EPSILON, FLT_EPSILON, "eps");
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 return retval;
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3825 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3826
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3827 /*
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3828
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3829 %!assert(eps(1/2),2^(-53))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3830 %!assert(eps(1),2^(-52))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3831 %!assert(eps(2),2^(-51))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3832 %!assert(eps(realmax),2^971)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3833 %!assert(eps(0),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3834 %!assert(eps(realmin/2),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3835 %!assert(eps(realmin/16),2^(-1074))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3836 %!assert(eps(Inf),NaN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3837 %!assert(eps(NaN),NaN)
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3838 %!assert(eps(single(1/2)),single(2^(-24)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3839 %!assert(eps(single(1)),single(2^(-23)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3840 %!assert(eps(single(2)),single(2^(-22)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3841 %!assert(eps(realmax('single')),single(2^104))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3842 %!assert(eps(single(0)),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3843 %!assert(eps(realmin('single')/2),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3844 %!assert(eps(realmin('single')/16),single(2^(-149)))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3845 %!assert(eps(single(Inf)),single(NaN))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3846 %!assert(eps(single(NaN)),single(NaN))
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3847
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3848 */
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3849
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3850
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3851 DEFUN (pi, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3852 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3853 @deftypefn {Built-in Function} {} pi (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3854 @deftypefnx {Built-in Function} {} pi (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3855 @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	3856 @deftypefnx {Built-in Function} {} pi (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3857 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	3858 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	3859 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	3860 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3861 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3862 #if defined (M_PI)
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3863 double pi_val = M_PI;
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3864 #else
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3865 double pi_val = 4.0 * atan (1.0);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3866 #endif
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3867
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3868 return fill_matrix (args, pi_val, "pi");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3869 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3870
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3871 DEFUN (realmax, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3872 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3873 @deftypefn {Built-in Function} {} realmax (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3874 @deftypefnx {Built-in Function} {} realmax (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3875 @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	3876 @deftypefnx {Built-in Function} {} realmax (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3877 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	3878 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	3879 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	3880 floating point arithmetic, @code{realmax} is approximately\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3881 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3882 1.7977e+308\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3883 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3884 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3885 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3886 $1.7977\\times10^{308}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3887 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3888 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3889 @seealso{realmin}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3890 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3891 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3892 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	3893 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3894
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3895 DEFUN (realmin, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3896 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3897 @deftypefn {Built-in Function} {} realmin (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3898 @deftypefnx {Built-in Function} {} realmin (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3899 @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	3900 @deftypefnx {Built-in Function} {} realmin (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3901 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	3902 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	3903 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	3904 64-bit IEEE floating point arithmetic, @code{realmin} is approximately\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3905 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3906 2.2251e-308\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3907 @end ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3908 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3909 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3910 $2.2251\\times10^{-308}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3911 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3912 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3913 @seealso{realmax}\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3914 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3915 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3916 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	3917 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3918
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3919 DEFUN (I, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3920 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3921 @deftypefn {Built-in Function} {} I (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3922 @deftypefnx {Built-in Function} {} I (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3923 @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	3924 @deftypefnx {Built-in Function} {} I (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3925 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	3926 to the pure imaginary unit, defined as\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3927 @iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3928 @tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3929 $\\sqrt{-1}$.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3930 @end tex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3931 @end iftex\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3932 @ifinfo\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3933 @code{sqrt (-1)}.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3934 @end ifinfo\n\
7001 8b0cfeb06365 [project @ 2007-10-10 18:02:59 by jwe] jwe parents: 6999 diff changeset	3935 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	3936 other purposes.\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3937 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3938 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3939 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	3940 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3941
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3942 DEFALIAS (i, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3943 DEFALIAS (J, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3944 DEFALIAS (j, I);
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3945
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3946 DEFUN (NA, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3947 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3948 @deftypefn {Built-in Function} {} NA (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3949 @deftypefnx {Built-in Function} {} NA (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3950 @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	3951 @deftypefnx {Built-in Function} {} NA (@dots{}, @var{class})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3952 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	3953 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	3954 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3955 {
7795 df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3956 return fill_matrix (args, lo_ieee_na_value (),
df9519e9990c Handle single precision eps values David Bateman <dbateman@free.fr> parents: 7789 diff changeset	3957 lo_ieee_float_na_value (), "NA");
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3958 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3959
7991 139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3960 /*
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3961
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3962 %!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	3963 %!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	3964
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3965 */
139f47cf17ab Change NA value to support single to double precision conversion David Bateman <dbateman@free.fr> parents: 7919 diff changeset	3966
5747 b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3967 DEFUN (false, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3968 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3969 @deftypefn {Built-in Function} {} false (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3970 @deftypefnx {Built-in Function} {} false (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3971 @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	3972 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	3973 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	3974 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3975 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3976 return fill_matrix (args, false, "false");
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3977 }
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3978
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3979 DEFUN (true, args, ,
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3980 "-- texinfo --\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3981 @deftypefn {Built-in Function} {} true (@var{x})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3982 @deftypefnx {Built-in Function} {} true (@var{n}, @var{m})\n\
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3983 @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	3984 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	3985 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	3986 @end deftypefn")
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3987 {
b09d4d0f5b63 [project @ 2006-04-07 06:43:10 by jwe] jwe parents: 5734 diff changeset	3988 return fill_matrix (args, true, "true");
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	3989 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	3990
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3991 template <class MT>
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3992 octave_value
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3993 identity_matrix (int nr, int nc)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3994 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3995 octave_value retval;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3996
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3997 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	3998
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	3999 if (nr == 1 && nc == 1)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4000 retval = one;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4001 else
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4002 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4003 dim_vector dims (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4004
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4005 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	4006
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4007 MT m (dims, zero);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4008
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4009 if (nr > 0 && nc > 0)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4010 {
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4011 int n = std::min (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4012
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4013 for (int i = 0; i < n; i++)
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4014 m(i,i) = one;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4015 }
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4016
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4017 retval = m;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4018 }
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4019
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4020 return retval;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4021 }
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4022
5058 11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4023 #define INSTANTIATE_EYE(T) \
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4024 template octave_value identity_matrix<T> (int, int)
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4025
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4026 INSTANTIATE_EYE (int8NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4027 INSTANTIATE_EYE (uint8NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4028 INSTANTIATE_EYE (int16NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4029 INSTANTIATE_EYE (uint16NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4030 INSTANTIATE_EYE (int32NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4031 INSTANTIATE_EYE (uint32NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4032 INSTANTIATE_EYE (int64NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4033 INSTANTIATE_EYE (uint64NDArray);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4034 INSTANTIATE_EYE (FloatNDArray);
5058 11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4035 INSTANTIATE_EYE (NDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4036 INSTANTIATE_EYE (boolNDArray);
11bea7392e69 [project @ 2004-11-01 21:06:44 by jwe] jwe parents: 5013 diff changeset	4037
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4038 static octave_value
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4039 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	4040 {
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4041 octave_value retval;
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4042
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4043 // 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	4044 // 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	4045 // value.
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 (! error_state)
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 switch (dt)
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 case oct_data_conv::dt_int8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4052 retval = identity_matrix<int8NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4053 break;
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 case oct_data_conv::dt_uint8:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4056 retval = identity_matrix<uint8NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4057 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4058
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4059 case oct_data_conv::dt_int16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4060 retval = identity_matrix<int16NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4061 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4062
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4063 case oct_data_conv::dt_uint16:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4064 retval = identity_matrix<uint16NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4065 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4066
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4067 case oct_data_conv::dt_int32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4068 retval = identity_matrix<int32NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4069 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4070
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4071 case oct_data_conv::dt_uint32:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4072 retval = identity_matrix<uint32NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4073 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4074
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4075 case oct_data_conv::dt_int64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4076 retval = identity_matrix<int64NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4077 break;
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4078
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4079 case oct_data_conv::dt_uint64:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4080 retval = identity_matrix<uint64NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4081 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4082
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4083 case oct_data_conv::dt_single:
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4084 retval = identity_matrix<FloatNDArray> (nr, nc);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4085 break;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4086
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4087 case oct_data_conv::dt_double:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4088 retval = identity_matrix<NDArray> (nr, nc);
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4089 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4090
4986 fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4091 case oct_data_conv::dt_logical:
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4092 retval = identity_matrix<boolNDArray> (nr, nc);
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4093 break;
fac558699d0f [project @ 2004-09-10 15:57:13 by jwe] jwe parents: 4948 diff changeset	4094
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4095 default:
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4096 error ("eye: invalid class name");
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4097 break;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4098 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4099 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4100
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4101 return retval;
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4102 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4103
4946 48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4104 #undef INT_EYE_MATRIX
48a39e2b2ab7 [project @ 2004-08-31 17:27:04 by jwe] jwe parents: 4945 diff changeset	4105
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	4106 DEFUN (eye, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4107 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4108 @deftypefn {Built-in Function} {} eye (@var{x})\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4109 @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	4110 @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	4111 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	4112 @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	4113 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	4114 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	4115 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	4116 respectively. For example,\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4117 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4118 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4119 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4120 eye (3)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4121 @result{} 1 0 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4122 0 1 0\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4123 0 0 1\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4124 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4125 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4126 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4127 The following expressions all produce the same result:\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4128 \n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4129 @example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4130 @group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4131 eye (2)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4132 @equiv{}\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4133 eye (2, 2)\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4134 @equiv{}\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4135 eye (size ([1, 2; 3, 4])\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4136 @end group\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4137 @end example\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4138 \n\
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4139 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	4140 the specified type, like\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4141 \n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4142 @example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4143 val = zeros (n,m, \"uint8\")\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4144 @end example\n\
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4145 \n\
6556 8810bbf321ce [project @ 2007-04-20 18:39:40 by jwe] jwe parents: 6518 diff changeset	4146 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	4147 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	4148 with @sc{Matlab}.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4149 @end deftypefn")
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4150 {
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4151 octave_value retval;
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4152
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4153 int nargin = args.length ();
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4154
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4155 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	4156
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4157 // Check for type information.
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4158
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4159 if (nargin > 0 && args(nargin-1).is_string ())
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4160 {
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4161 std::string nm = args(nargin-1).string_value ();
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4162 nargin--;
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4163
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4164 dt = oct_data_conv::string_to_data_type (nm);
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4165
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4166 if (error_state)
7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4167 return retval;
4945 4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4168 }
4bd917f8a4a7 [project @ 2004-08-31 15:09:17 by jwe] jwe parents: 4915 diff changeset	4169
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4170 switch (nargin)
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4171 {
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	4172 case 0:
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4173 retval = identity_matrix (1, 1, dt);
712 36ba0576bd1b [project @ 1994-09-19 14:18:15 by jwe] jwe parents: 649 diff changeset	4174 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4175
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	4176 case 1:
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4177 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4178 octave_idx_type nr, nc;
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4179 get_dimensions (args(0), "eye", nr, nc);
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4180
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4181 if (! error_state)
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4182 retval = identity_matrix (nr, nc, dt);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4183 }
610 14b2a186a5c0 [project @ 1994-08-14 00:55:49 by jwe] jwe parents: 597 diff changeset	4184 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4185
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4186 case 2:
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4187 {
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4188 octave_idx_type nr, nc;
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4189 get_dimensions (args(0), args(1), "eye", nr, nc);
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4190
87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4191 if (! error_state)
4948 7124436476cb [project @ 2004-08-31 17:57:21 by jwe] jwe parents: 4947 diff changeset	4192 retval = identity_matrix (nr, nc, dt);
3354 87721841efd7 [project @ 1999-11-17 19:06:11 by jwe] jwe parents: 3333 diff changeset	4193 }
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4194 break;
777 a2f9d3fd720c [project @ 1994-10-07 14:01:53 by jwe] jwe parents: 767 diff changeset	4195
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4196 default:
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4197 print_usage ();
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4198 break;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4199 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4200
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4201 return retval;
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4202 }
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	4203
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4204
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4205 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4206
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4207 %!assert (eye(3), [1, 0, 0; 0, 1, 0; 0, 0, 1]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4208 %!assert (eye(2, 3), [1, 0, 0; 0, 1, 0]);
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4209
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4210 %!assert (eye(3,'single'), single([1, 0, 0; 0, 1, 0; 0, 0, 1]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4211 %!assert (eye(2, 3,'single'), single([1, 0, 0; 0, 1, 0]));
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4212
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4213 %!assert (eye(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	4214 %!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	4215
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4216 %!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	4217
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4218 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4219
1957 0e6a0a271998 [project @ 1996-02-15 01:08:15 by jwe] jwe parents: 1940 diff changeset	4220 DEFUN (linspace, args, ,
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4221 "-- texinfo --\n\
f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4222 @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	4223 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	4224 @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	4225 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	4226 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	4227 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	4228 value of 100 is used.\n\
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4229 \n\
4455 abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4358 diff changeset	4230 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	4231 \n\
0fcc8d65b571 [project @ 2007-05-16 15:32:09 by jwe] jwe parents: 6561 diff changeset	4232 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	4233 fewer than two values are requested.\n\
3369 f37ca3017116 [project @ 1999-11-21 16:26:02 by jwe] jwe parents: 3361 diff changeset	4234 @end deftypefn")
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4235 {
3418 ca92c9d3f882 [project @ 2000-01-12 03:07:47 by jwe] jwe parents: 3373 diff changeset	4236 octave_value retval;
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4237
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4238 int nargin = args.length ();
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4239
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4240 octave_idx_type npoints = 100;
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4241
1940 1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4242 if (nargin != 2 && nargin != 3)
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4243 {
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4244 print_usage ();
1940 1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4245 return retval;
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4246 }
1b193e313c56 [project @ 1996-02-13 16:28:47 by jwe] jwe parents: 1884 diff changeset	4247
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4248 if (nargin == 3)
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4249 npoints = args(2).idx_type_value ();
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4250
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4251 if (! error_state)
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4252 {
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4253 octave_value arg_1 = args(0);
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4254 octave_value arg_2 = args(1);
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4255
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4256 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	4257 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4258 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	4259 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4260 FloatComplex x1 = arg_1.float_complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4261 FloatComplex x2 = arg_2.float_complex_value ();
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4262
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4263 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4264 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4265 FloatComplexRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4266
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4267 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4268 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4269 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4270 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4271 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4272 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4273 float x1 = arg_1.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4274 float x2 = arg_2.float_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4275
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4276 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4277 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4278 FloatRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4279
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4280 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4281 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4282 }
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4283 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4284 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4285 else
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4286 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4287 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	4288 {
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4289 Complex x1 = arg_1.complex_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4290 Complex x2 = arg_2.complex_value ();
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4291
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4292 if (! error_state)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4293 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4294 ComplexRowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4295
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4296 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4297 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4298 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4299 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4300 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4301 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4302 double x1 = arg_1.double_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4303 double x2 = arg_2.double_value ();
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 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4307 RowVector rv = linspace (x1, x2, npoints);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4308
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4309 if (! error_state)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4310 retval = rv;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7743 diff changeset	4311 }
3322 8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4312 }
8c6b4de3bdc8 [project @ 1999-10-26 21:33:27 by jwe] jwe parents: 3321 diff changeset	4313 }
1100 3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4314 }
4732 b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	4315 else
b484cdca27be [project @ 2004-02-04 04:32:48 by jwe] jwe parents: 4685 diff changeset	4316 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	4317
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4318 return retval;
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4319 }
3b6f6c5217e7 [project @ 1995-02-14 01:45:09 by jwe] jwe parents: 1032 diff changeset	4320
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4321
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4322 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4323
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4324 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4325 %! 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	4326 %! 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	4327 %! 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	4328 %! 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	4329 %! && 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	4330 %! && 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	4331
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4332
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4333 % 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	4334
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4335 %!error <Invalid call to linspace.*> linspace ();
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4336 %!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	4337
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4338 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4339 %! 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	4340
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4341 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4342
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4343 // 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	4344 // 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	4345
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4346 DEFUN (resize, args, ,
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4347 "-- texinfo --\n\
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4348 @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	4349 @deftypefnx {Built-in Function} {} resize (@var{x}, @var{m}, @var{n})\n\
6174 d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4350 Destructively resize @var{x}.\n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4351 \n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4352 @strong{Values in @var{x} are not preserved as they are with\n\
6175 a4ecbadedc17 [project @ 2006-11-16 18:19:20 by jwe] jwe parents: 6174 diff changeset	4353 @code{reshape}.}\n\
6174 d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4354 \n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4355 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	4356 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	4357 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	4358 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	4359 the result are @var{m}-by-@var{n}.\n\
d3c599afc455 [project @ 2006-11-16 17:52:02 by jwe] jwe parents: 6156 diff changeset	4360 @seealso{reshape}\n\
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4361 @end deftypefn")
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4362 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4363 octave_value retval;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4364 int nargin = args.length ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4365
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4366 if (nargin == 2)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4367 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4368 Array<double> vec = args(1).vector_value ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4369 int ndim = vec.length ();
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4370 if (ndim == 1)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4371 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4372 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	4373 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4374 retval = retval.resize (dim_vector (m, m), true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4375 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4376 else
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4377 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4378 dim_vector dv;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4379 dv.resize (ndim);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4380 for (int i = 0; i < ndim; i++)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4381 dv(i) = static_cast<octave_idx_type> (vec(i));
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4382 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4383 retval = retval.resize (dv, true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4384 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4385 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4386 else if (nargin == 3)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4387 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4388 octave_idx_type m = static_cast<octave_idx_type>
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4389 (args(1).scalar_value());
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4390 octave_idx_type n = static_cast<octave_idx_type>
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4391 (args(2).scalar_value());
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4392 if (!error_state)
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4393 {
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4394 retval = args(0);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4395 retval = retval.resize (dim_vector (m, n), true);
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4396 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4397 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4398 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4399 print_usage ();
5731 c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4400 return retval;
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4401 }
c7d5a534afa5 [project @ 2006-04-03 19:33:26 by jwe] jwe parents: 5724 diff changeset	4402
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5747 diff changeset	4403 // FIXME -- should use octave_idx_type for dimensions.
5734 a7d2c47371d2 [project @ 2006-04-04 18:29:13 by jwe] jwe parents: 5731 diff changeset	4404
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4405 DEFUN (reshape, args, ,
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4406 "-- texinfo --\n\
6671 9042b00fc45e [project @ 2007-05-30 06:33:29 by jwe] jwe parents: 6630 diff changeset	4407 @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	4408 @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	4409 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	4410 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	4411 column-major order (like Fortran arrays are stored).\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4412 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4413 For example,\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4414 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4415 @example\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4416 @group\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4417 reshape ([1, 2, 3, 4], 2, 2)\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4418 @result{} 1 3\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4419 2 4\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4420 @end group\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4421 @end example\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4422 \n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4423 @noindent\n\
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4424 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	4425 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	4426 \n\
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4427 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	4428 by an empty argument.\n\
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4429 @end deftypefn")
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4430 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4431 octave_value retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4432
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4433 int nargin = args.length ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4434
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4435 Array<int> new_size;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4436
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4437 if (nargin == 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4438 new_size = args(1).int_vector_value ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4439 else if (nargin > 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4440 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4441 new_size.resize (nargin-1);
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4442 int empty_dim = -1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4443
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4444 for (int i = 1; i < nargin; i++)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4445 {
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4446 if (args(i).is_empty ())
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4447 if (empty_dim > 0)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4448 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4449 error ("reshape: only a single dimension can be unknown");
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4450 break;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4451 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4452 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4453 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4454 empty_dim = i;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4455 new_size(i-1) = 1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4456 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4457 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4458 {
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 5991 diff changeset	4459 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	4460
5013 1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4461 if (error_state)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4462 break;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4463 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4464 }
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4465
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4466 if (! error_state && (empty_dim > 0))
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4467 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4468 int nel = 1;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4469 for (int i = 0; i < nargin - 1; i++)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4470 nel *= new_size(i);
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4471
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4472 if (nel == 0)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4473 new_size(empty_dim-1) = 0;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4474 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4475 {
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4476 int size_empty_dim = args(0).numel () / nel;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4477
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4478 if (args(0).numel () != size_empty_dim * nel)
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4479 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	4480 else
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4481 new_size(empty_dim-1) = size_empty_dim;
1eb9ce5c0152 [project @ 2004-09-21 22:18:07 by jwe] jwe parents: 4986 diff changeset	4482 }
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4483 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4484 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4485 else
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4486 {
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4487 print_usage ();
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4488 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4489 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4490
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4491 if (error_state)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4492 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4493 error ("reshape: invalid arguments");
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4494 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4495 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4496
4739 7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4497 // 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	4498 // elements.
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4499
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4500 int n = new_size.length ();
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4501
4739 7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4502 while (n > 2)
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4503 {
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4504 if (new_size(n-1) == 1)
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4505 n--;
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4506 else
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4507 break;
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4508 }
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4509
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4510 new_size.resize (n);
7bd3748e2735 [project @ 2004-02-05 18:53:18 by jwe] jwe parents: 4732 diff changeset	4511
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4512 if (n < 2)
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4513 {
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4514 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	4515 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4516 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4517
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4518 dim_vector new_dims;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4519
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4520 new_dims.resize (n);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4521
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	4522 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	4523 new_dims(i) = new_size(i);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4524
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4525 octave_value arg = args(0);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4526
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4527 if (new_dims.numel () == arg.numel ())
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4528 retval = (new_dims == arg.dims ()) ? arg : arg.reshape (new_dims);
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4529 else
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4530 error ("reshape: size mismatch");
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4531
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4532 return retval;
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4533 }
fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4565 diff changeset	4534
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4535 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4536
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4537 %!assert(size (reshape (ones (4, 4), 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	4538 %!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	4539 %!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	4540 %!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	4541
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4542 %!assert(size (reshape (ones (4, 4, 'single'), 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	4543 %!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	4544 %!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	4545 %!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	4546
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4547 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4548 %! 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	4549 %! 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	4550
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4551 %!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	4552 %!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	4553
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4554 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4555
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4556 DEFUN (squeeze, args, ,
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4557 "-- texinfo --\n\
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4558 @deftypefn {Built-in Function} {} squeeze (@var{x})\n\
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4559 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	4560 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	4561 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	4562 @end deftypefn")
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4563 {
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4564 octave_value retval;
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4565
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4566 if (args.length () == 1)
4545 c16f153836a0 [project @ 2003-10-24 04:45:45 by jwe] jwe parents: 4532 diff changeset	4567 retval = args(0).squeeze ();
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4568 else
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5798 diff changeset	4569 print_usage ();
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4570
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4571 return retval;
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4572 }
01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4516 diff changeset	4573
6945 6bbf56a9718a [project @ 2007-10-02 20:47:22 by jwe] jwe parents: 6887 diff changeset	4574 // Compute various norms of the vector X.
6bbf56a9718a [project @ 2007-10-02 20:47:22 by jwe] jwe parents: 6887 diff changeset	4575
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4576 DEFUN (norm, args, ,
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4577 "-- texinfo --\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4578 @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	4579 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	4580 missing, @code{p = 2} is assumed.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4581 \n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4582 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	4583 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4584 @table @asis\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4585 @item @var{p} = @code{1}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4586 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	4587 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4588 @item @var{p} = @code{2}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4589 Largest singular value of @var{a}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4590 \n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4591 @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	4592 @cindex infinity norm\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4593 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	4594 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4595 @item @var{p} = @code{\"fro\"}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4596 @cindex Frobenius norm\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4597 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	4598 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4599 @item other @var{p}, @code{@var{p} > 1}\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4600 @cindex general p-norm \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4601 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	4602 @end table\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4603 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4604 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	4605 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4606 @table @asis\n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4607 @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	4608 @code{max (abs (@var{a}))}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4609 \n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4610 @item @var{p} = @code{-Inf}\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4611 @code{min (abs (@var{a}))}.\n\
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4612 \n\
7189 e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4613 @item @var{p} = @code{\"fro\"}\n\
e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman] dbateman parents: 7145 diff changeset	4614 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	4615 \n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4616 @item @var{p} = 0\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4617 Hamming norm - the number of nonzero elements.\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4618 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4619 @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	4620 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	4621 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4622 @item other @var{p} @code{@var{p} < 1}\n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4623 the p-pseudonorm defined as above.\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4624 @end table\n\
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4625 \n\
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4626 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	4627 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	4628 column norms are computed.\n\
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4629 @seealso{cond, svd}\n\
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4630 @end deftypefn")
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4631 {
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4632 octave_value_list retval;
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4633
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4634 int nargin = args.length ();
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4635
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4636 if (nargin >= 1 && nargin <= 3)
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4637 {
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4638 octave_value x_arg = args(0);
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4639
4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4640 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	4641 {
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4642 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	4643 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	4644 else
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4645 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	4646 }
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4647 else if (x_arg.ndims () == 2)
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4648 {
8303 b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4649 enum { sfmatrix, sfcols, sfrows, sffrob, sfinf } strflag = sfmatrix;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4650 if (nargin > 1 && args(nargin-1).is_string ())
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4651 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4652 std::string str = args(nargin-1).string_value ();
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4653 if (str == "cols" \|\| str == "columns")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4654 strflag = sfcols;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4655 else if (str == "rows")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4656 strflag = sfrows;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4657 else if (str == "fro")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4658 strflag = sffrob;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4659 else if (str == "inf")
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4660 strflag = sfinf;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4661 else
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4662 error ("norm: unrecognized option: %s", str.c_str ());
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4663 // 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	4664 nargin --;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4665 }
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4666 else if (nargin > 1 && ! args(1).is_scalar_type ())
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4667 gripe_wrong_type_arg ("norm", args(1), true);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4668
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4669 if (! error_state)
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4670 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4671 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	4672 switch (strflag)
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4673 {
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4674 case sfmatrix:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4675 retval(0) = xnorm (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4676 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4677 case sfcols:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4678 retval(0) = xcolnorms (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4679 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4680 case sfrows:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4681 retval(0) = xrownorms (x_arg, p_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4682 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4683 case sffrob:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4684 retval(0) = xfrobnorm (x_arg);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4685 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4686 case sfinf:
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4687 retval(0) = xnorm (x_arg, octave_Inf);
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4688 break;
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4689 }
b11c31849b44 improve norm computation capabilities Jaroslav Hajek <highegg@gmail.com> parents: 8286 diff changeset	4690 }
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4691 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4692 else
6953 4567a35e0777 [project @ 2007-10-04 02:53:11 by jwe] jwe parents: 6945 diff changeset	4693 error ("norm: only valid for 2-D objects");
6508 184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4694 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4695 else
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4696 print_usage ();
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4697
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4698 return retval;
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4699 }
184ab67c3bc1 [project @ 2007-04-07 00:43:09 by jwe] jwe parents: 6401 diff changeset	4700
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4701 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4702 %!shared x
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4703 %! 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	4704 %!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	4705 %!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	4706 %!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	4707 %!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	4708 %!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	4709 %!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	4710 %!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	4711 %!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	4712 %!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	4713 %!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	4714 %!shared m
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4715 %! 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	4716 %!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	4717 %!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	4718 %!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	4719 %!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	4720 %!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	4721 %! 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	4722 %! 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	4723 %! 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	4724 %!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	4725 %!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	4726
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4727 %!shared x
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4728 %! 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	4729 %!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	4730 %!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	4731 %!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	4732 %!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	4733 %!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	4734 %!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	4735 %!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	4736 %!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	4737 %!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	4738 %!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	4739 %!shared m
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4740 %! 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	4741 %!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	4742 %!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	4743 %!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	4744 %!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	4745 %!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	4746 %! 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	4747 %! 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	4748 %! 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	4749 %!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	4750 %!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	4751 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4752
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4753 #define UNARY_OP_DEFUN_BODY(F) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4754 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4755 octave_value retval; \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4756 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4757 if (args.length () == 1) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4758 retval = F (args(0)); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4759 else \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4760 print_usage (); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4761 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4762 return retval
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4763
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4764 DEFUN (not, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4765 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4766 @deftypefn {Built-in Function} {} not (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4767 This function is equivalent to @code{! x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4768 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4769 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4770 UNARY_OP_DEFUN_BODY (op_not);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4771 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4772
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4773 DEFUN (uplus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4774 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4775 @deftypefn {Built-in Function} {} uplus (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4776 This function is equivalent to @code{+ x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4777 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4778 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4779 UNARY_OP_DEFUN_BODY (op_uplus);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4780 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4781
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4782 DEFUN (uminus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4783 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4784 @deftypefn {Built-in Function} {} uminus (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4785 This function is equivalent to @code{- x}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4786 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4787 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4788 UNARY_OP_DEFUN_BODY (op_uminus);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4789 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4790
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4791 DEFUN (transpose, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4792 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4793 @deftypefn {Built-in Function} {} transpose (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4794 This function is equivalent to @code{x.'}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4795 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4796 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4797 UNARY_OP_DEFUN_BODY (op_transpose);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4798 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4799
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4800 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4801
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4802 %!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	4803 %!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	4804 %!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	4805 %!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	4806 %!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	4807 %!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	4808
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4809 %!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	4810
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4811 %!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	4812 %!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	4813 %!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	4814 %!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	4815 %!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	4816 %!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	4817
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4818 %!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	4819
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4820 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4821
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4822 DEFUN (ctranspose, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4823 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4824 @deftypefn {Built-in Function} {} ctranspose (@var{x})\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4825 This function is equivalent to @code{x'}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4826 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4827 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4828 UNARY_OP_DEFUN_BODY (op_hermitian);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4829 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4830
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4831 /*
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4832
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4833 %!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	4834 %!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	4835 %!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	4836 %!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	4837 %!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	4838 %!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	4839
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4840 %!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	4841
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4842 %!assert (single(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	4843 %!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	4844 %!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	4845 %!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	4846 %!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	4847 %!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	4848
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4849 %!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	4850
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4851 */
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	4852
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4853 #define BINARY_OP_DEFUN_BODY(F) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4854 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4855 octave_value retval; \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4856 \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4857 if (args.length () == 2) \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4858 retval = F (args(0), args(1)); \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4859 else \
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4860 print_usage (); \
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 return retval
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4863
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4864 DEFUN (plus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4865 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4866 @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	4867 This function is equivalent to @code{x + y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4868 @end deftypefn")
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 BINARY_OP_DEFUN_BODY (op_add);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4871 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4872
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4873 DEFUN (minus, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4874 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4875 @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	4876 This function is equivalent to @code{x - y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4877 @end deftypefn")
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 BINARY_OP_DEFUN_BODY (op_sub);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4880 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4881
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4882 DEFUN (mtimes, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4883 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4884 @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	4885 This function is equivalent to @code{x * y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4886 @end deftypefn")
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 BINARY_OP_DEFUN_BODY (op_mul);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4889 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4890
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4891 DEFUN (mrdivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4892 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4893 @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	4894 This function is equivalent to @code{x / y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4895 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4896 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4897 BINARY_OP_DEFUN_BODY (op_div);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4898 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4899
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4900 DEFUN (mpower, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4901 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4902 @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	4903 This function is equivalent to @code{x ^ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4904 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4905 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4906 BINARY_OP_DEFUN_BODY (op_pow);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4907 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4908
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4909 DEFUN (mldivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4910 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4911 @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	4912 This function is equivalent to @code{x \\ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4913 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4914 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4915 BINARY_OP_DEFUN_BODY (op_ldiv);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4918 DEFUN (lt, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4919 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4920 @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	4921 This function is equivalent to @code{x < y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4922 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4923 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4924 BINARY_OP_DEFUN_BODY (op_lt);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4925 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4926
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4927 DEFUN (le, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4928 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4929 @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	4930 This function is equivalent to @code{x <= y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4931 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4932 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4933 BINARY_OP_DEFUN_BODY (op_le);
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4934 }
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4935
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4936 DEFUN (eq, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4937 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4938 @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	4939 This function is equivalent to @code{x == y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4940 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4941 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4942 BINARY_OP_DEFUN_BODY (op_eq);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4945 DEFUN (ge, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4946 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4947 @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	4948 This function is equivalent to @code{x >= y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4949 @end deftypefn")
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 BINARY_OP_DEFUN_BODY (op_ge);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4954 DEFUN (gt, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4955 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4956 @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	4957 This function is equivalent to @code{x > y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4958 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4959 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4960 BINARY_OP_DEFUN_BODY (op_gt);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4963 DEFUN (ne, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4964 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4965 @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	4966 This function is equivalent to @code{x != y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4967 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4968 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4969 BINARY_OP_DEFUN_BODY (op_ne);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4972 DEFUN (times, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4973 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4974 @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	4975 This function is equivalent to @code{x .* y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4976 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4977 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4978 BINARY_OP_DEFUN_BODY (op_el_mul);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4981 DEFUN (rdivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4982 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4983 @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	4984 This function is equivalent to @code{x ./ y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4985 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4986 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4987 BINARY_OP_DEFUN_BODY (op_el_div);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4990 DEFUN (power, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4991 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4992 @deftypefn {Built-in Function} {} power (@var{x}, @var{y})\n\
7623 431f3788f5c4 minor doc patch David Bateman <dbateman@free.fr> parents: 7620 diff changeset	4993 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	4994 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4995 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4996 BINARY_OP_DEFUN_BODY (op_el_pow);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	4999 DEFUN (ldivide, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5000 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5001 @deftypefn {Built-in Function} {} ldivide (@var{x}, @var{y})\n\
7623 431f3788f5c4 minor doc patch David Bateman <dbateman@free.fr> parents: 7620 diff changeset	5002 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	5003 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5004 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5005 BINARY_OP_DEFUN_BODY (op_el_ldiv);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5008 DEFUN (and, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5009 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5010 @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	5011 This function is equivalent to @code{x & y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5012 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5013 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5014 BINARY_OP_DEFUN_BODY (op_el_and);
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
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5017 DEFUN (or, args, ,
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5018 "-- texinfo --\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5019 @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	5020 This function is equivalent to @code{x \| y}.\n\
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5021 @end deftypefn")
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5022 {
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6508 diff changeset	5023 BINARY_OP_DEFUN_BODY (op_el_or);
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
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5026 static double tic_toc_timestamp = -1.0;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5027
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5028 DEFUN (tic, args, nargout,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5029 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5030 @deftypefn {Built-in Function} {} tic ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5031 @deftypefnx {Built-in Function} {} toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5032 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	5033 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	5034 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	5035 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5036 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5037 tic ();\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5038 # many computations later...\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5039 elapsed_time = toc ();\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5040 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5041 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5042 @noindent\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5043 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	5044 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	5045 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5046 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	5047 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	5048 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5049 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5050 @group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5051 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	5052 @result{} 5\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5053 @end group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5054 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5055 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5056 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	5057 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	5058 recent call to @code{tic}.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5059 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5060 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	5061 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	5062 @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	5063 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	5064 doing nothing at all. For example,\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5065 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5066 @example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5067 @group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5068 tic (); sleep (5); toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5069 @result{} 5\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5070 t = cputime (); sleep (5); cputime () - t\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5071 @result{} 0\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5072 @end group\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5073 @end example\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5074 \n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5075 @noindent\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5076 (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	5077 coarse resolution.)\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5078 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5079 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5080 octave_value retval;
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5081
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5082 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5083
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5084 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5085 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5086
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5087 octave_time now;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5088
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5089 double tmp = now.double_value ();
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5090
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5091 if (nargout > 0)
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5092 retval = static_cast<octave_uint64> (1e6 * tmp);
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5093 else
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5094 tic_toc_timestamp = tmp;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5095
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5096 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5097 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5098
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5099 DEFUN (toc, args, nargout,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5100 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5101 @deftypefn {Built-in Function} {} toc ()\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5102 See tic.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5103 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5104 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5105 octave_value retval;
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5106
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5107 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5108
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5109 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5110 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5111
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5112 if (tic_toc_timestamp < 0)
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5113 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5114 warning ("toc called before timer set");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5115 if (nargout > 0)
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5116 retval = Matrix ();
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5117 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5118 else
7065 97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5119 {
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5120 octave_time now;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5121
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5122 double tmp = now.double_value () - tic_toc_timestamp;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5123
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5124 if (nargout > 0)
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5125 retval = tmp;
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5126 else
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5127 octave_stdout << "Elapsed time is " << tmp << " seconds.\n";
97db94ae2cf0 [project @ 2007-10-25 05:50:55 by jwe] jwe parents: 7045 diff changeset	5128 }
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5129
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5130 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5131 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5132
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5133 DEFUN (cputime, args, ,
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5134 "-- texinfo --\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5135 @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	5136 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	5137 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	5138 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	5139 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	5140 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	5141 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	5142 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	5143 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	5144 CPU time used is nonzero.\n\
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5145 @end deftypefn")
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5146 {
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5147 octave_value_list retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5148 int nargin = args.length ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5149 double usr = 0.0;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5150 double sys = 0.0;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5151
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5152 if (nargin != 0)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5153 warning ("tic: ignoring extra arguments");
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5154
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5155 #if defined (HAVE_GETRUSAGE)
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5156
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5157 struct rusage ru;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5158
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5159 getrusage (RUSAGE_SELF, &ru);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5160
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5161 usr = static_cast<double> (ru.ru_utime.tv_sec) +
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5162 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	5163
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5164 sys = static_cast<double> (ru.ru_stime.tv_sec) +
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5165 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	5166
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5167 #elif defined (HAVE_TIMES) && defined (HAVE_SYS_TIMES_H)
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 struct tms t;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5170
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5171 times (&t);
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 unsigned long ticks;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5174 unsigned long seconds;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5175 unsigned long fraction;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5176
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5177 ticks = t.tms_utime + t.tms_cutime;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5178 fraction = ticks % HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5179 seconds = ticks / HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5180
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5181 usr = static_cast<double> (seconds) + static_cast<double>(fraction) /
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5182 static_cast<double>(HZ);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5183
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5184 ticks = t.tms_stime + t.tms_cstime;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5185 fraction = ticks % HZ;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5186 seconds = ticks / HZ;
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 sys = static_cast<double> (seconds) + static_cast<double>(fraction) /
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5189 static_cast<double>(HZ);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5190
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5191 #elif defined (__WIN32__)
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5192
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5193 HANDLE hProcess = GetCurrentProcess ();
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5194 FILETIME ftCreation, ftExit, ftUser, ftKernel;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5195 GetProcessTimes (hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser);
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5196
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5197 int64_t itmp = (reinterpret_cast<int64_t > (&ftUser));
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5198 usr = static_cast<double> (itmp) * 1e-7;
7045 271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5199
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5200 itmp = (reinterpret_cast<int64_t > (&ftKernel));
7145 d169c9f4a697 [project @ 2007-11-09 17:43:06 by jwe] jwe parents: 7144 diff changeset	5201 sys = static_cast<double> (itmp) * 1e-7;
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 #endif
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5204
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5205 retval (2) = sys;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5206 retval (1) = usr;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5207 retval (0) = sys + usr;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5208
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5209 return retval;
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5210 }
271fa61d8fae [project @ 2007-10-22 11:52:38 by dbateman] dbateman parents: 7026 diff changeset	5211
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5212 DEFUN (sort, args, nargout,
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5213 "-- texinfo --\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5214 @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	5215 @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	5216 @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	5217 @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	5218 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	5219 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	5220 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5221 For example,\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5222 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5223 @example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5224 @group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5225 sort ([1, 2; 2, 3; 3, 1])\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5226 @result{} 1 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5227 2 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5228 3 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5229 @end group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5230 @end example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5231 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5232 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	5233 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	5234 matrix. For example,\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5235 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5236 @example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5237 @group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5238 [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	5239 @result{} s = 1 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5240 2 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5241 3 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5242 @result{} i = 1 3\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5243 2 1\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5244 3 2\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5245 @end group\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5246 @end example\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5247 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5248 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	5249 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	5250 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	5251 @code{mode} are `ascend' or `descend'.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5252 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5253 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	5254 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	5255 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5256 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	5257 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	5258 \n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5259 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	5260 ordered lists.\n\
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5261 @end deftypefn")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5262 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5263 octave_value_list retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5264
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5265 int nargin = args.length ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5266 sortmode smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5267
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5268 if (nargin < 1 \|\| nargin > 3)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5269 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5270 print_usage ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5271 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5272 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5273
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5274 bool return_idx = nargout > 1;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5275
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5276 octave_value arg = args(0);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5277
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5278 int dim = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5279 if (nargin > 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5280 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5281 if (args(1).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5282 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5283 std::string mode = args(1).string_value();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5284 if (mode == "ascend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5285 smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5286 else if (mode == "descend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5287 smode = DESCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5288 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5289 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5290 error ("sort: mode must be either \"ascend\" or \"descend\"");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5291 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5292 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5293 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5294 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5295 dim = args(1).nint_value () - 1;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5296 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5297
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5298 if (nargin > 2)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5299 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5300 if (args(1).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5301 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5302 print_usage ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5303 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5304 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5305
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5306 if (! args(2).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5307 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5308 error ("sort: mode must be a string");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5309 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5310 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5311 std::string mode = args(2).string_value();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5312 if (mode == "ascend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5313 smode = ASCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5314 else if (mode == "descend")
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5315 smode = DESCENDING;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5316 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5317 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5318 error ("sort: mode must be either \"ascend\" or \"descend\"");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5319 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5320 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5321 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5322
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5323 dim_vector dv = arg.dims ();
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5324 if (error_state)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5325 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5326 gripe_wrong_type_arg ("sort", arg);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5327 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5328 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5329 if (nargin == 1 \|\| args(1).is_string ())
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5330 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5331 // Find first non singleton dimension
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5332 for (int i = 0; i < dv.length (); i++)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5333 if (dv(i) > 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5334 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5335 dim = i;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5336 break;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5337 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5338 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5339 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5340 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5341 if (dim < 0 \|\| dim > dv.length () - 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5342 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5343 error ("sort: dim must be a valid dimension");
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5344 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5345 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5346 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5347
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5348 if (return_idx)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5349 {
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5350 Array<octave_idx_type> sidx;
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 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	5353 retval (1) = NDArray (sidx, true);
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5354 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5355 else
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5356 retval(0) = arg.sort (dim, smode);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5357
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5358 return retval;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5359 }
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5360
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5361 /*
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5362
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5363 %% Double
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5364 %!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	5365 %!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	5366 %!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	5367 %!error (sort ([NaN, 1, -1, 2, Inf], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5368 %!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	5369 %!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	5370 %!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	5371 %!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	5372 %!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	5373 %!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	5374 %!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	5375 %!assert (sort (1), 1)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5376
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5377 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5378 %! [v, i] = sort ([NaN, 1, -1, Inf, 1]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5379 %! assert (v, [-1, 1, 1, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5380 %! assert (i, [3, 2, 5, 4, 1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5381
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5382 %% Complex
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5383 %!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	5384 %!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	5385 %!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	5386 %!error (sort ([NaN, 1i, -1, 2, Inf], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5387 %!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	5388 %!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	5389 %!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	5390 %!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	5391 %!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	5392 %!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	5393 %!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	5394 %!assert (sort (1i), 1i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5395
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5396 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5397 %! [v, i] = sort ([NaN, 1i, -1, Inf, 1, 1i]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5398 %! assert (v, [1, 1i, 1i, -1, Inf, NaN])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5399 %! assert (i, [5, 2, 6, 3, 4, 1])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5400
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5401 %% Single
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5402 %!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	5403 %!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	5404 %!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	5405 %!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	5406 %!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	5407 %!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	5408 %!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	5409 %!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	5410 %!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	5411 %!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	5412 %!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	5413 %!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	5414
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5415 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5416 %! [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	5417 %! 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	5418 %! 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	5419
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5420 %% Single Complex
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5421 %!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	5422 %!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	5423 %!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	5424 %!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	5425 %!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	5426 %!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	5427 %!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	5428 %!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	5429 %!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	5430 %!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	5431 %!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	5432 %!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	5433
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5434 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5435 %! [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	5436 %! 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	5437 %! 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	5438
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5439 %% Bool
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5440 %!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	5441 %!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	5442 %!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	5443 %!error (sort ([true, false, true, false], 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5444 %!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	5445 %!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	5446 %!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	5447 %!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	5448 %!assert (sort (true), true)
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 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5451 %! [v, i] = sort ([true, false, true, false]);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5452 %! assert (v, [false, false, true, true])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5453 %! assert (i, [2, 4, 1, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5454
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5455 %% Sparse Double
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5456 %!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	5457 %!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	5458 %!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	5459 %!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	5460 %!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	5461 %!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	5462 %!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	5463 %!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	5464
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5465 %!shared a
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5466 %! a = randn (10, 10);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5467 %! a (a < 0) = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5468 %!assert (sort (sparse (a)), sparse (sort (a)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5469 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5470 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5471 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5472 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5473 %! [vs, is] = sort (sparse (a));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5474 %! assert (vs, sparse (v))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5475 %! assert (is, i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5476
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5477 %% Sparse Complex
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5478 %!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	5479 %!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	5480 %!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	5481 %!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	5482 %!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	5483 %!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	5484 %!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	5485 %!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	5486
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5487 %!shared a
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5488 %! a = randn (10, 10);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5489 %! a (a < 0) = 0;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5490 %! a = 1i * a;
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5491 %!assert (sort (sparse (a)), sparse (sort (a)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5492 %!assert (sort (sparse (a), 1), sparse (sort (a, 1)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5493 %!assert (sort (sparse (a), 2), sparse (sort (a, 2)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5494 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5495 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5496 %! [vs, is] = sort (sparse (a));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5497 %! assert (vs, sparse (v))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5498 %! assert (is, i)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5499
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5500 %% Sparse Bool
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5501 %!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	5502 %!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	5503 %!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	5504 %!error (sort (sparse ([true, false, true, false], 3)))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5505 %!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	5506 %!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	5507 %!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	5508 %!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	5509
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5510 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5511 %! [v, i] = sort (sparse([true, false, true, false]));
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5512 %! assert (v, sparse([false, false, true, true]))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5513 %! assert (i, [2, 4, 1, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5514
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5515 %% Cell string array
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5516 %!shared a, b, c
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5517 %! a = {"Alice", "Cecile", "Eric", "Barry", "David"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5518 %! b = {"Alice", "Barry", "Cecile", "David", "Eric"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5519 %! c = {"Eric", "David", "Cecile", "Barry", "Alice"};
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5520 %!assert (sort (a), b);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5521 %!assert (sort (a, 1), a)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5522 %!assert (sort (a, 2), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5523 %!error (sort (a, 3))
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5524 %!assert (sort (a, "ascend"), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5525 %!assert (sort (a, 2, "ascend"), b)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5526 %!assert (sort (a, "descend"), c)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5527 %!assert (sort (a, 2, "descend"), c)
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5528
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5529 %!test
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5530 %! [v, i] = sort (a);
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5531 %! assert (i, [1, 4, 2, 5, 3])
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5532
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7795 diff changeset	5533 %!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	5534 %!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	5535
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5536 */
402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7269 diff changeset	5537
523 4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5538 /*
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5539 ;;; Local Variables: ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5540 ;;; mode: C++ ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5541 ;;; End: ***
4a07f0083ab0 [project @ 1994-07-20 18:33:47 by jwe] jwe parents: diff changeset	5542 */

Mercurial > octave

annotate src/data.cc @ 8347:fa78cb8d8a5c