octave-nkf: src/DLD-FUNCTIONS/cellfun.cc annotate

annotate src/DLD-FUNCTIONS/cellfun.cc @ 10043:7fbdeaa9b0e0

fix common_size optimization

author	Jaroslav Hajek <highegg@gmail.com>
date	Wed, 30 Dec 2009 06:01:51 +0100
parents	f349847c4541
children	2d7a8c227713

rev	line source
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	1 /*
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	2
8920 eb63fbe60fab update copyright notices John W. Eaton <jwe@octave.org> parents: 8828 diff changeset	3 Copyright (C) 2005, 2006, 2007, 2008, 2009 Mohamed Kamoun
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	4 Copyright (C) 2009 Jaroslav Hajek
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	5
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	6 This file is part of Octave.
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	7
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	8 Octave is free software; you can redistribute it and/or modify it
59592dcbb5d8 [project @ 2005-03-15 16:04:56 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: 7001 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: 7001 diff changeset	11 option) any later version.
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	12
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	13 Octave is distributed in the hope that it will be useful, but WITHOUT
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	16 for more details.
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	17
59592dcbb5d8 [project @ 2005-03-15 16:04:56 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: 7001 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: 7001 diff changeset	20 <http://www.gnu.org/licenses/>.
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	21
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	22 */
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	23
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	24 #ifdef HAVE_CONFIG_H
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	25 #include <config.h>
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	26 #endif
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	27
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	28 #include <string>
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	29 #include <vector>
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	30 #include <list>
8994 a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	31 #include <memory>
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	32
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	33 #include "lo-mappers.h"
8377 25bc2d31e1bf improve OCTAVE_LOCAL_BUFFER Jaroslav Hajek <highegg@gmail.com> parents: 8373 diff changeset	34 #include "oct-locbuf.h"
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	35
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	36 #include "Cell.h"
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	37 #include "oct-map.h"
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	38 #include "defun-dld.h"
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	39 #include "parse.h"
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	40 #include "variables.h"
5451 ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	41 #include "ov-colon.h"
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	42 #include "unwind-prot.h"
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	43 #include "gripes.h"
9728 70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	44 #include "utils.h"
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	45
8994 a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	46 // Rationale:
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	47 // The octave_base_value::subsasgn method carries too much overhead for
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	48 // per-element assignment strategy.
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	49 // This class will optimize the most optimistic and most likely case
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	50 // when the output really is scalar by defining a hierarchy of virtual
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	51 // collectors specialized for some scalar types.
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	52
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	53 class scalar_col_helper
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	54 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	55 public:
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	56 virtual bool collect (octave_idx_type i, const octave_value& val) = 0;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	57 virtual octave_value result (void) = 0;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	58 virtual ~scalar_col_helper (void) { }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	59 };
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	60
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	61 // The default collector represents what was previously done in the main loop.
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	62 // This reuses the existing assignment machinery via octave_value::subsasgn,
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	63 // which can perform all sorts of conversions, but is relatively slow.
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	64
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	65 class scalar_col_helper_def : public scalar_col_helper
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	66 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	67 std::list<octave_value_list> idx_list;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	68 octave_value resval;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	69 public:
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	70 scalar_col_helper_def (const octave_value& val, const dim_vector& dims)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	71 : idx_list (1), resval (val)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	72 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	73 idx_list.front ().resize (1);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	74 if (resval.dims () != dims)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	75 resval.resize (dims);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	76 }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	77 ~scalar_col_helper_def (void) { }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	78
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	79 bool collect (octave_idx_type i, const octave_value& val)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	80 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	81 if (val.numel () == 1)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	82 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	83 idx_list.front ()(0) = static_cast<double> (i + 1);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	84 resval = resval.subsasgn ("(", idx_list, val);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	85 }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	86 else
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	87 error ("cellfun: expecting all values to be scalars for UniformOutput = true");
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	88
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	89 return true;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	90 }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	91 octave_value result (void)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	92 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	93 return resval;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	94 }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	95 };
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	96
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	97 template <class T>
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	98 struct scalar_query_helper { };
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	99
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	100 #define DEF_QUERY_HELPER(T, TEST, QUERY) \
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	101 template <> \
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	102 struct scalar_query_helper<T> \
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	103 { \
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	104 static bool has_value (const octave_value& val) \
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	105 { return TEST; } \
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	106 static T get_value (const octave_value& val) \
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	107 { return QUERY; } \
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	108 }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	109
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	110 DEF_QUERY_HELPER (double, val.is_real_scalar (), val.scalar_value ());
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	111 DEF_QUERY_HELPER (Complex, val.is_complex_scalar (), val.complex_value ());
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	112 DEF_QUERY_HELPER (float, val.is_single_type () && val.is_real_scalar (),
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	113 val.float_scalar_value ());
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	114 DEF_QUERY_HELPER (FloatComplex, val.is_single_type () && val.is_complex_scalar (),
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	115 val.float_complex_value ());
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	116 DEF_QUERY_HELPER (bool, val.is_bool_scalar (), val.bool_value ());
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	117 // FIXME: More?
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	118
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	119 // This specializes for collecting elements of a single type, by accessing
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	120 // an array directly. If the scalar is not valid, it returns false.
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	121
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	122 template <class NDA>
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	123 class scalar_col_helper_nda : public scalar_col_helper
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	124 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	125 NDA arrayval;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	126 typedef typename NDA::element_type T;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	127 public:
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	128 scalar_col_helper_nda (const octave_value& val, const dim_vector& dims)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	129 : arrayval (dims)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	130 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	131 arrayval(0) = scalar_query_helper<T>::get_value (val);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	132 }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	133 ~scalar_col_helper_nda (void) { }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	134
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	135 bool collect (octave_idx_type i, const octave_value& val)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	136 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	137 bool retval = scalar_query_helper<T>::has_value (val);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	138 if (retval)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	139 arrayval(i) = scalar_query_helper<T>::get_value (val);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	140 return retval;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	141 }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	142 octave_value result (void)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	143 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	144 return arrayval;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	145 }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	146 };
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	147
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	148 template class scalar_col_helper_nda<NDArray>;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	149 template class scalar_col_helper_nda<FloatNDArray>;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	150 template class scalar_col_helper_nda<ComplexNDArray>;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	151 template class scalar_col_helper_nda<FloatComplexNDArray>;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	152 template class scalar_col_helper_nda<boolNDArray>;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	153
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	154 // the virtual constructor.
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	155 scalar_col_helper *
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	156 make_col_helper (const octave_value& val, const dim_vector& dims)
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	157 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	158 scalar_col_helper *retval;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	159
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	160 if (val.is_bool_scalar ())
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	161 retval = new scalar_col_helper_nda<boolNDArray> (val, dims);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	162 else if (val.is_complex_scalar ())
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	163 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	164 if (val.is_single_type ())
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	165 retval = new scalar_col_helper_nda<FloatComplexNDArray> (val, dims);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	166 else
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	167 retval = new scalar_col_helper_nda<ComplexNDArray> (val, dims);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	168 }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	169 else if (val.is_real_scalar ())
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	170 {
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	171 if (val.is_single_type ())
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	172 retval = new scalar_col_helper_nda<FloatNDArray> (val, dims);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	173 else
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	174 retval = new scalar_col_helper_nda<NDArray> (val, dims);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	175 }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	176 else
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	177 retval = new scalar_col_helper_def (val, dims);
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	178
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	179 return retval;
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	180 }
a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	181
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	182 DEFUN_DLD (cellfun, args, nargout,
8715 954b6f69f51d doc fixes John W. Eaton <jwe@octave.org> parents: 8377 diff changeset	183 "-- texinfo --\n\
6854 364765c17648 [project @ 2007-09-01 00:03:10 by dbateman] dbateman parents: 6704 diff changeset	184 @deftypefn {Loadable Function} {} cellfun (@var{name}, @var{c})\n\
364765c17648 [project @ 2007-09-01 00:03:10 by dbateman] dbateman parents: 6704 diff changeset	185 @deftypefnx {Loadable Function} {} cellfun (\"size\", @var{c}, @var{k})\n\
364765c17648 [project @ 2007-09-01 00:03:10 by dbateman] dbateman parents: 6704 diff changeset	186 @deftypefnx {Loadable Function} {} cellfun (\"isclass\", @var{c}, @var{class})\n\
364765c17648 [project @ 2007-09-01 00:03:10 by dbateman] dbateman parents: 6704 diff changeset	187 @deftypefnx {Loadable Function} {} cellfun (@var{func}, @var{c})\n\
364765c17648 [project @ 2007-09-01 00:03:10 by dbateman] dbateman parents: 6704 diff changeset	188 @deftypefnx {Loadable Function} {} cellfun (@var{func}, @var{c}, @var{d})\n\
364765c17648 [project @ 2007-09-01 00:03:10 by dbateman] dbateman parents: 6704 diff changeset	189 @deftypefnx {Loadable Function} {[@var{a}, @var{b}] =} cellfun (@dots{})\n\
364765c17648 [project @ 2007-09-01 00:03:10 by dbateman] dbateman parents: 6704 diff changeset	190 @deftypefnx {Loadable Function} {} cellfun (@dots{}, 'ErrorHandler', @var{errfunc})\n\
364765c17648 [project @ 2007-09-01 00:03:10 by dbateman] dbateman parents: 6704 diff changeset	191 @deftypefnx {Loadable Function} {} cellfun (@dots{}, 'UniformOutput', @var{val})\n\
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	192 \n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	193 Evaluate the function named @var{name} on the elements of the cell array\n\
5543 4d52e637a72a [project @ 2005-11-21 16:13:47 by jwe] jwe parents: 5451 diff changeset	194 @var{c}. Elements in @var{c} are passed on to the named function\n\
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	195 individually. The function @var{name} can be one of the functions\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	196 \n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	197 @table @code\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	198 @item isempty\n\
5543 4d52e637a72a [project @ 2005-11-21 16:13:47 by jwe] jwe parents: 5451 diff changeset	199 Return 1 for empty elements.\n\
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	200 @item islogical\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	201 Return 1 for logical elements.\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	202 @item isreal\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	203 Return 1 for real elements.\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	204 @item length\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	205 Return a vector of the lengths of cell elements.\n\
5543 4d52e637a72a [project @ 2005-11-21 16:13:47 by jwe] jwe parents: 5451 diff changeset	206 @item ndims\n\
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	207 Return the number of dimensions of each element.\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	208 @item prodofsize\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	209 Return the product of dimensions of each element.\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	210 @item size\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	211 Return the size along the @var{k}-th dimension.\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	212 @item isclass\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	213 Return 1 for elements of @var{class}.\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	214 @end table\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	215 \n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	216 Additionally, @code{cellfun} accepts an arbitrary function @var{func}\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	217 in the form of an inline function, function handle, or the name of a\n\
9036 58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	218 function (in a character string). In the case of a character string\n\
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	219 argument, the function must accept a single argument named @var{x}, and\n\
9036 58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	220 it must return a string value. The function can take one or more arguments,\n\
58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	221 with the inputs args given by @var{c}, @var{d}, etc. Equally the function\n\
58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	222 can return one or more output arguments. For example\n\
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	223 \n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	224 @example\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	225 @group\n\
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	226 cellfun (@@atan2, @{1, 0@}, @{0, 1@})\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	227 @result{}ans = [1.57080 0.00000]\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	228 @end group\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	229 @end example\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	230 \n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	231 Note that the default output argument is an array of the same size as the\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	232 input arguments.\n\
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	233 Input arguments that are singleton (1x1) cells will be automatically expanded\n\
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	234 to the size of the other arguments.\n\
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	235 \n\
8828 8463d1a2e544 Doc fixes. Brian Gough <bjg@network-theory.co.uk> parents: 8715 diff changeset	236 If the parameter 'UniformOutput' is set to true (the default), then the function\n\
8347 fa78cb8d8a5c corrections for typos Brian Gough<bjg@network-theory.co.uk> parents: 8286 diff changeset	237 must return a single element which will be concatenated into the\n\
9036 58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	238 return value. If 'UniformOutput' is false, the outputs are concatenated in\n\
58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	239 a cell array. For example\n\
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	240 \n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	241 @example\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	242 @group\n\
6623 545847da3b88 [project @ 2007-05-15 02:23:08 by jwe] jwe parents: 6550 diff changeset	243 cellfun (\"tolower(x)\", @{\"Foo\", \"Bar\", \"FooBar\"@},\n\
545847da3b88 [project @ 2007-05-15 02:23:08 by jwe] jwe parents: 6550 diff changeset	244 \"UniformOutput\",false)\n\
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	245 @result{} ans = @{\"foo\", \"bar\", \"foobar\"@}\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	246 @end group\n\
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	247 @end example\n\
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	248 \n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	249 Given the parameter 'ErrorHandler', then @var{errfunc} defines a function to\n\
9036 58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	250 call in case @var{func} generates an error. The form of the function is\n\
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	251 \n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	252 @example\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	253 function [@dots{}] = errfunc (@var{s}, @dots{})\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	254 @end example\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	255 \n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	256 where there is an additional input argument to @var{errfunc} relative to\n\
9036 58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	257 @var{func}, given by @var{s}. This is a structure with the elements\n\
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	258 'identifier', 'message' and 'index', giving respectively the error\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	259 identifier, the error message, and the index into the input arguments\n\
9036 58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	260 of the element that caused the error. For example\n\
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	261 \n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	262 @example\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	263 @group\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	264 function y = foo (s, x), y = NaN; endfunction\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	265 cellfun (@@factorial, @{-1,2@},'ErrorHandler',@@foo)\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	266 @result{} ans = [NaN 2]\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	267 @end group\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	268 @end example\n\
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	269 \n\
8286 6f2d95255911 fix @seealso references to point to existing anchors Thorsten Meyer <thorsten.meyier@gmx.de> parents: 8096 diff changeset	270 @seealso{isempty, islogical, isreal, length, ndims, numel, size}\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5544 diff changeset	271 @end deftypefn")
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	272 {
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	273 octave_value_list retval;
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	274 int nargin = args.length ();
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	275 int nargout1 = (nargout < 1 ? 1 : nargout);
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	276
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	277 if (nargin < 2)
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	278 {
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	279 error ("cellfun: you must supply at least 2 arguments");
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5784 diff changeset	280 print_usage ();
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	281 return retval;
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	282 }
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	283
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	284 octave_value func = args(0);
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	285
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	286 if (! args(1).is_cell ())
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	287 {
5543 4d52e637a72a [project @ 2005-11-21 16:13:47 by jwe] jwe parents: 5451 diff changeset	288 error ("cellfun: second argument must be a cell array");
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	289
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	290 return retval;
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	291 }
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	292
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	293 if (func.is_string ())
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	294 {
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	295 const Cell f_args = args(1).cell_value ();
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	296
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	297 octave_idx_type k = f_args.numel ();
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	298
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	299 std::string name = func.string_value ();
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	300
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	301 if (name == "isempty")
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	302 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	303 boolNDArray result (f_args.dims ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	304 for (octave_idx_type count = 0; count < k ; count++)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	305 result(count) = f_args.elem(count).is_empty ();
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	306 retval(0) = result;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	307 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	308 else if (name == "islogical")
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	309 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	310 boolNDArray result (f_args.dims ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	311 for (octave_idx_type count= 0; count < k ; count++)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	312 result(count) = f_args.elem(count).is_bool_type ();
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	313 retval(0) = result;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	314 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	315 else if (name == "isreal")
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	316 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	317 boolNDArray result (f_args.dims ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	318 for (octave_idx_type count= 0; count < k ; count++)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	319 result(count) = f_args.elem(count).is_real_type ();
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	320 retval(0) = result;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	321 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	322 else if (name == "length")
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	323 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	324 NDArray result (f_args.dims ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	325 for (octave_idx_type count= 0; count < k ; count++)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	326 result(count) = static_cast<double> (f_args.elem(count).length ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	327 retval(0) = result;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	328 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	329 else if (name == "ndims")
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	330 {
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	331 NDArray result (f_args.dims ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	332 for (octave_idx_type count = 0; count < k ; count++)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	333 result(count) = static_cast<double> (f_args.elem(count).ndims ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	334 retval(0) = result;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	335 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	336 else if (name == "prodofsize" \|\| name == "numel")
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	337 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	338 NDArray result (f_args.dims ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	339 for (octave_idx_type count = 0; count < k ; count++)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	340 result(count) = static_cast<double> (f_args.elem(count).numel ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	341 retval(0) = result;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	342 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	343 else if (name == "size")
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	344 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	345 if (nargin == 3)
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	346 {
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	347 int d = args(2).nint_value () - 1;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	348
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	349 if (d < 0)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	350 error ("cellfun: third argument must be a positive integer");
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	351
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	352 if (! error_state)
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	353 {
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	354 NDArray result (f_args.dims ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	355 for (octave_idx_type count = 0; count < k ; count++)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	356 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	357 dim_vector dv = f_args.elem(count).dims ();
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	358 if (d < dv.length ())
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	359 result(count) = static_cast<double> (dv(d));
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	360 else
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	361 result(count) = 1.0;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	362 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	363 retval(0) = result;
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	364 }
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	365 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	366 else
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	367 error ("not enough arguments for `size'");
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	368 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	369 else if (name == "isclass")
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	370 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	371 if (nargin == 3)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	372 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	373 std::string class_name = args(2).string_value();
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	374 boolNDArray result (f_args.dims ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	375 for (octave_idx_type count = 0; count < k ; count++)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	376 result(count) = (f_args.elem(count).class_name() == class_name);
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	377
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	378 retval(0) = result;
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	379 }
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	380 else
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	381 error ("not enough arguments for `isclass'");
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	382 }
10033 f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	383 else if (name == "subsref" && nargin == 5 && nargout == 1
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	384 && args(2).numel () == 1 && args(2).is_cell ()
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	385 && args(3).is_string ()
10043 7fbdeaa9b0e0 fix common_size optimization Jaroslav Hajek <highegg@gmail.com> parents: 10033 diff changeset	386 && args(3).xtolower ().string_value () == "uniformoutput"
7fbdeaa9b0e0 fix common_size optimization Jaroslav Hajek <highegg@gmail.com> parents: 10033 diff changeset	387 && ! args(4).bool_value () && ! error_state)
10033 f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	388 {
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	389 // This optimizes the case of applying the same index expression to
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	390 // multiple values. We decode the subscript just once. uniformoutput must
10043 7fbdeaa9b0e0 fix common_size optimization Jaroslav Hajek <highegg@gmail.com> parents: 10033 diff changeset	391 // be set to false.
10033 f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	392
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	393 const Cell tmpc = args(2).cell_value ();
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	394 octave_value subs = tmpc(0);
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	395
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	396 std::string type;
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	397 std::list<octave_value_list> idx;
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	398 decode_subscripts ("subsref", subs, type, idx);
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	399
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	400 if (! error_state)
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	401 {
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	402 Cell result (f_args.dims ());
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	403 for (octave_idx_type count = 0; count < k && ! error_state; count++)
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	404 result(count) = f_args.elem (count).subsref (type, idx);
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	405
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	406 retval(0) = result;
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	407 }
f349847c4541 optimize cellfun (@subsref, args, {subs}, uniformoutput, true) case Jaroslav Hajek <highegg@gmail.com> parents: 9988 diff changeset	408 }
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	409 else
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	410 {
9728 70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	411 if (! valid_identifier (name))
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	412 {
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	413
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	414 std::string fcn_name = unique_symbol_name ("__cellfun_fcn_");
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	415 std::string fname = "function y = ";
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	416 fname.append (fcn_name);
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	417 fname.append ("(x) y = ");
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	418 octave_function *ptr_func = extract_function (args(0), "cellfun",
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	419 fcn_name, fname, "; endfunction");
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	420 if (ptr_func && ! error_state)
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	421 func = octave_value (ptr_func, true);
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	422 }
70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9684 diff changeset	423
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	424 func = symbol_table::find_function (name);
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	425 if (func.is_undefined ())
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	426 error ("cellfun: invalid function name: %s", name.c_str ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	427 }
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	428 }
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	429
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	430 if (error_state \|\| ! retval.empty ())
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	431 return retval;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	432
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	433 if (func.is_function_handle () \|\| func.is_inline_function ()
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	434 \|\| func.is_function ())
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	435 {
9377 610bf90fce2a update unwind_protect usage everywhere Jaroslav Hajek <highegg@gmail.com> parents: 9307 diff changeset	436 unwind_protect::frame_id_t uwp_frame = unwind_protect::begin_frame ();
610bf90fce2a update unwind_protect usage everywhere Jaroslav Hajek <highegg@gmail.com> parents: 9307 diff changeset	437 unwind_protect::protect_var (buffer_error_messages);
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	438
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	439 bool uniform_output = true;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	440 octave_value error_handler;
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	441
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	442 while (nargin > 3 && args(nargin-2).is_string())
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	443 {
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	444 std::string arg = args(nargin-2).string_value();
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	445
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	446 std::transform (arg.begin (), arg.end (),
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	447 arg.begin (), tolower);
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	448
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	449 if (arg == "uniformoutput")
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	450 uniform_output = args(nargin-1).bool_value();
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	451 else if (arg == "errorhandler")
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	452 {
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	453 if (args(nargin-1).is_function_handle () \|\|
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	454 args(nargin-1).is_inline_function ())
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	455 {
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	456 error_handler = args(nargin-1);
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	457 }
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	458 else if (args(nargin-1).is_string ())
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	459 {
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	460 std::string err_name = args(nargin-1).string_value ();
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	461 error_handler = symbol_table::find_function (err_name);
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	462 if (error_handler.is_undefined ())
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	463 {
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	464 error ("cellfun: invalid function name: %s", err_name.c_str ());
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	465 break;
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	466 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	467 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	468 else
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	469 {
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	470 error ("invalid errorhandler value");
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	471 break;
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	472 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	473 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	474 else
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	475 {
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	476 error ("cellfun: unrecognized parameter %s",
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	477 arg.c_str());
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	478 break;
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	479 }
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	480
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	481 nargin -= 2;
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	482 }
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	483
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	484 nargin -= 1;
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	485
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	486 octave_value_list inputlist (nargin, octave_value ());
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	487
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	488 OCTAVE_LOCAL_BUFFER (Cell, inputs, nargin);
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	489 OCTAVE_LOCAL_BUFFER (bool, mask, nargin);
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	490
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	491 // This is to prevent copy-on-write.
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	492 const Cell *cinputs = inputs;
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	493
9684 c5ff5f858cfd omission from last patch Jaroslav Hajek <highegg@gmail.com> parents: 9683 diff changeset	494 octave_idx_type k = 1;
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	495
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	496 dim_vector fdims (1, 1);
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	497
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	498 if (error_state)
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	499 goto cellfun_err;
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	500
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	501 for (int j = 0; j < nargin; j++)
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	502 {
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	503 if (! args(j+1).is_cell ())
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	504 {
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	505 error ("cellfun: arguments must be cells");
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	506 goto cellfun_err;
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	507 }
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	508
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	509 inputs[j] = args(j+1).cell_value ();
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	510 mask[j] = inputs[j].numel () != 1;
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	511 if (! mask[j])
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	512 inputlist(j) = cinputs[j](0);
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	513 }
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	514
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	515 for (int j = 0; j < nargin; j++)
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	516 {
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	517 if (mask[j])
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	518 {
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	519 fdims = inputs[j].dims ();
9683 5b3b9dcfd59c fix crash in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9678 diff changeset	520 k = inputs[j].numel ();
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	521 for (int i = j+1; i < nargin; i++)
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	522 {
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	523 if (mask[i] && inputs[i].dims () != fdims)
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	524 {
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	525 error ("cellfun: Dimensions mismatch.");
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	526 goto cellfun_err;
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	527 }
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	528 }
9683 5b3b9dcfd59c fix crash in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9678 diff changeset	529 break;
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	530 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	531 }
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	532
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	533 if (error_handler.is_defined ())
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	534 buffer_error_messages++;
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	535
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	536 if (uniform_output)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	537 {
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	538 OCTAVE_LOCAL_BUFFER (std::auto_ptr<scalar_col_helper>, retptr, nargout1);
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	539
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	540 for (octave_idx_type count = 0; count < k ; count++)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	541 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	542 for (int j = 0; j < nargin; j++)
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	543 {
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	544 if (mask[j])
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	545 inputlist(j) = cinputs[j](count);
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	546 }
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	547
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	548 octave_value_list tmp = func.do_multi_index_op (nargout, inputlist);
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	549
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	550 if (error_state && error_handler.is_defined ())
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	551 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	552 Octave_map msg;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	553 msg.assign ("identifier", last_error_id ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	554 msg.assign ("message", last_error_message ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	555 msg.assign ("index", octave_value(double (count + static_cast<octave_idx_type>(1))));
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	556 octave_value_list errlist = inputlist;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	557 errlist.prepend (msg);
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	558 buffer_error_messages--;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	559 error_state = 0;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	560 tmp = error_handler.do_multi_index_op (nargout, errlist);
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	561 buffer_error_messages++;
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	562
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	563 if (error_state)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	564 goto cellfun_err;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	565 }
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	566
9459 cb0b21f34abc avoid double error messages in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9450 diff changeset	567 if (error_state)
cb0b21f34abc avoid double error messages in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9450 diff changeset	568 goto cellfun_err;
cb0b21f34abc avoid double error messages in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9450 diff changeset	569
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	570 if (tmp.length () < nargout1)
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	571 {
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	572 if (tmp.length () < nargout)
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	573 {
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	574 error ("cellfun: too many output arguments");
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	575 goto cellfun_err;
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	576 }
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	577 else
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	578 nargout1 = 0;
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	579 }
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	580
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	581 if (count == 0)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	582 {
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	583 for (int j = 0; j < nargout1; j++)
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	584 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	585 octave_value val = tmp(j);
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	586
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	587 if (val.numel () == 1)
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	588 retptr[j].reset (make_col_helper (val, fdims));
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	589 else
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	590 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	591 error ("cellfun: expecting all values to be scalars for UniformOutput = true");
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	592 break;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	593 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	594 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	595 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	596 else
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	597 {
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	598 for (int j = 0; j < nargout1; j++)
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	599 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	600 octave_value val = tmp(j);
5989 e049385342f6 [project @ 2006-09-14 02:10:46 by jwe] jwe parents: 5988 diff changeset	601
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	602 if (! retptr[j]->collect (count, val))
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	603 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	604 // FIXME: A more elaborate structure would allow again a virtual
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	605 // constructor here.
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	606 retptr[j].reset (new scalar_col_helper_def (retptr[j]->result (),
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	607 fdims));
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	608 retptr[j]->collect (count, val);
8994 a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	609 }
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	610 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	611 }
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	612
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	613 if (error_state)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	614 break;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	615 }
8994 a8d30dc1beec cellfun optimizations Jaroslav Hajek <highegg@gmail.com> parents: 8985 diff changeset	616
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	617 retval.resize (nargout1);
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	618 for (int j = 0; j < nargout1; j++)
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	619 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	620 if (retptr[j].get ())
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	621 retval(j) = retptr[j]->result ();
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	622 else
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	623 retval(j) = Matrix ();
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	624 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	625 }
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	626 else
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	627 {
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	628 OCTAVE_LOCAL_BUFFER (Cell, results, nargout1);
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	629 for (int j = 0; j < nargout1; j++)
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	630 results[j].resize (fdims);
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	631
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	632 for (octave_idx_type count = 0; count < k ; count++)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	633 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	634 for (int j = 0; j < nargin; j++)
9465 40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	635 {
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	636 if (mask[j])
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	637 inputlist(j) = cinputs[j](count);
40de4692c860 auto-expanding scalar cells in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9459 diff changeset	638 }
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	639
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	640 octave_value_list tmp = func.do_multi_index_op (nargout, inputlist);
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	641
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	642 if (error_state && error_handler.is_defined ())
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	643 {
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	644 Octave_map msg;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	645 msg.assign ("identifier", last_error_id ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	646 msg.assign ("message", last_error_message ());
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	647 msg.assign ("index", octave_value(double (count + static_cast<octave_idx_type>(1))));
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	648 octave_value_list errlist = inputlist;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	649 errlist.prepend (msg);
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	650 buffer_error_messages--;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	651 error_state = 0;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	652 tmp = error_handler.do_multi_index_op (nargout, errlist);
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	653 buffer_error_messages++;
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	654
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	655 if (error_state)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	656 goto cellfun_err;
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	657 }
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	658
9459 cb0b21f34abc avoid double error messages in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9450 diff changeset	659 if (error_state)
cb0b21f34abc avoid double error messages in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9450 diff changeset	660 goto cellfun_err;
cb0b21f34abc avoid double error messages in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9450 diff changeset	661
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	662 if (tmp.length () < nargout1)
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	663 {
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	664 if (tmp.length () < nargout)
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	665 {
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	666 error ("cellfun: too many output arguments");
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	667 goto cellfun_err;
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	668 }
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	669 else
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	670 nargout1 = 0;
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	671 }
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	672
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	673
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	674 for (int j = 0; j < nargout1; j++)
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	675 results[j](count) = tmp(j);
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	676 }
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	677
9988 76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	678 retval.resize(nargout1);
76cf4aec34e9 allow functions returning no value in cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9740 diff changeset	679 for (int j = 0; j < nargout1; j++)
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	680 retval(j) = results[j];
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	681 }
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	682
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	683 cellfun_err:
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	684 if (error_state)
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	685 retval = octave_value_list();
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	686
9377 610bf90fce2a update unwind_protect usage everywhere Jaroslav Hajek <highegg@gmail.com> parents: 9307 diff changeset	687 unwind_protect::run_frame (uwp_frame);
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	688 }
9450 cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	689 else
cf714e75c656 implement overloaded function handles Jaroslav Hajek <highegg@gmail.com> parents: 9377 diff changeset	690 error ("cellfun: first argument must be a string or function handle");
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	691
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	692 return retval;
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	693 }
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	694
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	695 /*
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	696
8373 63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	697 %% Test function to check the "Errorhandler" option
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	698 %!function [z] = cellfunerror (S, varargin)
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	699 %! z = S;
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	700 %! endfunction
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	701
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	702 %% First input argument can be a string, an inline function,
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	703 %% a function_handle or an anonymous function
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	704 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	705 %! A = cellfun ("islogical", {true, 0.1, false, i*2});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	706 %! assert (A, [true, false, true, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	707 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	708 %! A = cellfun (inline ("islogical (x)", "x"), {true, 0.1, false, i*2});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	709 %! assert (A, [true, false, true, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	710 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	711 %! A = cellfun (@islogical, {true, 0.1, false, i*2});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	712 %! assert (A, [true, false, true, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	713 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	714 %! A = cellfun (@(x) islogical(x), {true, 0.1, false, i*2});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	715 %! assert (A, [true, false, true, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	716
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	717 %% First input argument can be the special string "isreal",
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	718 %% "isempty", "islogical", "length", "ndims" or "prodofsize"
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	719 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	720 %! A = cellfun ("isreal", {true, 0.1, false, i*2, [], "abc"});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	721 %! assert (A, [true, true, true, false, true, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	722 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	723 %! A = cellfun ("isempty", {true, 0.1, false, i*2, [], "abc"});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	724 %! assert (A, [false, false, false, false, true, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	725 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	726 %! A = cellfun ("islogical", {true, 0.1, false, i*2, [], "abc"});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	727 %! assert (A, [true, false, true, false, false, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	728 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	729 %! A = cellfun ("length", {true, 0.1, false, i*2, [], "abc"});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	730 %! assert (A, [1, 1, 1, 1, 0, 3]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	731 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	732 %! A = cellfun ("ndims", {[1, 2; 3, 4]; (cell (1,2,3,4))});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	733 %! assert (A, [2; 4]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	734 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	735 %! A = cellfun ("prodofsize", {[1, 2; 3, 4], (cell (1,2,3,4))});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	736 %! assert (A, [4, 24]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	737
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	738 %% Number of input and output arguments may not be limited to one
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	739 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	740 %! A = cellfun (@(x,y,z) x + y + z, {1, 1, 1}, {2, 2, 2}, {3, 4, 5});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	741 %! assert (A, [6, 7, 8]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	742 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	743 %! A = cellfun (@(x,y,z) x + y + z, {1, 1, 1}, {2, 2, 2}, {3, 4, 5}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	744 %! "UniformOutput", false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	745 %! assert (A, {6, 7, 8});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	746 %!test %% Two input arguments of different types
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	747 %! A = cellfun (@(x,y) islogical (x) && ischar (y), {false, true}, {"a", 3});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	748 %! assert (A, [true, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	749 %!test %% Pass another variable to the anonymous function
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	750 %! y = true; A = cellfun (@(x) islogical (x) && y, {false, 0.3});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	751 %! assert (A, [true, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	752 %!test %% Three ouptut arguments of different type
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	753 %! [A, B, C] = cellfun (@find, {10, 11; 0, 12}, "UniformOutput", false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	754 %! assert (isequal (A, {true, true; [], true}));
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	755 %! assert (isequal (B, {true, true; [], true}));
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	756 %! assert (isequal (C, {10, 11; [], 12}));
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	757
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	758 %% Input arguments can be of type cell array of logical
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	759 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	760 %! A = cellfun (@(x,y) x == y, {false, true}, {true, true});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	761 %! assert (A, [false, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	762 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	763 %! A = cellfun (@(x,y) x == y, {false; true}, {true; true}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	764 %! "UniformOutput", true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	765 %! assert (A, [false; true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	766 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	767 %! A = cellfun (@(x) x, {false, true; false, true}, "UniformOutput", false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	768 %! assert (A, {false, true; false, true});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	769 %!test %% Three ouptut arguments of same type
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	770 %! [A, B, C] = cellfun (@find, {true, false; false, true}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	771 %! "UniformOutput", false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	772 %! assert (isequal (A, {true, []; [], true}));
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	773 %! assert (isequal (B, {true, []; [], true}));
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	774 %! assert (isequal (C, {true, []; [], true}));
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	775 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	776 %! A = cellfun (@(x,y) cell2str (x,y), {true}, {true}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	777 %! "ErrorHandler", @cellfunerror);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	778 %! assert (isfield (A, "identifier"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	779 %! assert (isfield (A, "message"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	780 %! assert (isfield (A, "index"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	781 %! assert (isempty (A.message), false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	782 %! assert (A.index, 1);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	783 %!test %% Overwriting setting of "UniformOutput" true
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	784 %! A = cellfun (@(x,y) cell2str (x,y), {true}, {true}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	785 %! "UniformOutput", true, "ErrorHandler", @cellfunerror);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	786 %! assert (isfield (A, "identifier"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	787 %! assert (isfield (A, "message"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	788 %! assert (isfield (A, "index"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	789 %! assert (isempty (A.message), false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	790 %! assert (A.index, 1);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	791
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	792 %% Input arguments can be of type cell array of numeric
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	793 %!test
9622 40cbcdf12b54 fix broken tests Jaroslav Hajek <highegg@gmail.com> parents: 9465 diff changeset	794 %! A = cellfun (@(x,y) x>y, {1.1, 4.2}, {3.1, 2+3*i});
8373 63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	795 %! assert (A, [false, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	796 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	797 %! A = cellfun (@(x,y) x>y, {1.1, 4.2; 2, 4}, {3.1, 2; 2, 4+2*i}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	798 %! "UniformOutput", true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	799 %! assert (A, [false, true; false, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	800 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	801 %! A = cellfun (@(x,y) x:y, {1.1, 4}, {3.1, 6}, "UniformOutput", false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	802 %! assert (isequal (A{1}, [1.1, 2.1, 3.1]));
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	803 %! assert (isequal (A{2}, [4, 5, 6]));
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	804 %!test %% Three ouptut arguments of different type
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	805 %! [A, B, C] = cellfun (@find, {10, 11; 0, 12}, "UniformOutput", false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	806 %! assert (isequal (A, {true, true; [], true}));
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	807 %! assert (isequal (B, {true, true; [], true}));
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	808 %! assert (isequal (C, {10, 11; [], 12}));
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	809 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	810 %! A = cellfun (@(x,y) cell2str(x,y), {1.1, 4}, {3.1, 6}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	811 %! "ErrorHandler", @cellfunerror);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	812 %! B = isfield (A(1), "message") && isfield (A(1), "index");
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	813 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	814 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	815 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	816 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	817 %! assert ([A(1).index, A(2).index], [1, 2]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	818 %!test %% Overwriting setting of "UniformOutput" true
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	819 %! A = cellfun (@(x,y) cell2str(x,y), {1.1, 4}, {3.1, 6}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	820 %! "UniformOutput", true, "ErrorHandler", @cellfunerror);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	821 %! B = isfield (A(1), "message") && isfield (A(1), "index");
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	822 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	823 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	824 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	825 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	826 %! assert ([A(1).index, A(2).index], [1, 2]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	827
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	828 %% Input arguments can be of type cell arrays of character or strings
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	829 %!error %% "UniformOutput" false should be used
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	830 %! A = cellfun (@(x,y) x>y, {"ad", "c", "ghi"}, {"cc", "d", "fgh"});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	831 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	832 %! A = cellfun (@(x,y) x>y, {"a"; "f"}, {"c"; "d"}, "UniformOutput", true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	833 %! assert (A, [false; true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	834 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	835 %! A = cellfun (@(x,y) x:y, {"a", "d"}, {"c", "f"}, "UniformOutput", false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	836 %! assert (A, {"abc", "def"});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	837 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	838 %! A = cellfun (@(x,y) cell2str(x,y), {"a", "d"}, {"c", "f"}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	839 %! "ErrorHandler", @cellfunerror);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	840 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	841 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	842 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	843 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	844 %! assert ([A(1).index, A(2).index], [1, 2]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	845 %!test %% Overwriting setting of "UniformOutput" true
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	846 %! A = cellfun (@(x,y) cell2str(x,y), {"a", "d"}, {"c", "f"}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	847 %! "UniformOutput", true, "ErrorHandler", @cellfunerror);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	848 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	849 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	850 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	851 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	852 %! assert ([A(1).index, A(2).index], [1, 2]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	853
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	854 %% Structures cannot be handled by cellfun
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	855 %!error
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	856 %! vst1.a = 1.1; vst1.b = 4.2; vst2.a = 3.1; vst2.b = 2;
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	857 %! A = cellfun (@(x,y) (x.a < y.a) && (x.b > y.b), vst1, vst2);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	858
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	859 %% Input arguments can be of type cell array of cell arrays
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	860 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	861 %! A = cellfun (@(x,y) x{1} < y{1}, {{1.1}, {4.2}}, {{3.1}, {2}});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	862 %! assert (A, [1, 0], 1e-16);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	863 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	864 %! A = cellfun (@(x,y) x{1} < y{1}, {{1.1}; {4.2}}, {{3.1}; {2}}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	865 %! "UniformOutput", true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	866 %! assert (A, [1; 0], 1e-16);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	867 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	868 %! A = cellfun (@(x,y) x{1} < y{1}, {{1.1}, {4.2}}, {{3.1}, {2}}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	869 %! "UniformOutput", false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	870 %! assert (A, {true, false});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	871 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	872 %! A = cellfun (@(x,y) mat2str(x,y), {{1.1}, {4.2}}, {{3.1}, {2}}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	873 %! "ErrorHandler", @cellfunerror);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	874 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	875 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	876 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	877 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	878 %! assert ([A(1).index, A(2).index], [1, 2]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	879 %!test %% Overwriting setting of "UniformOutput" true
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	880 %! A = cellfun (@(x,y) mat2str(x,y), {{1.1}, {4.2}}, {{3.1}, {2}}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	881 %! "UniformOutput", true, "ErrorHandler", @cellfunerror);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	882 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	883 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	884 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	885 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	886 %! assert ([A(1).index, A(2).index], [1, 2]);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	887
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	888 %% Input arguments can be of type cell array of structure arrays
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	889 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	890 %! a = struct ("a", 1, "b", 2); b = struct ("a", 1, "b", 3);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	891 %! A = cellfun (@(x,y) (x.a == y.a) && (x.b < y.b), {a}, {b});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	892 %! assert (A, true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	893 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	894 %! a = struct ("a", 1, "b", 2); b = struct ("a", 1, "b", 3);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	895 %! A = cellfun (@(x,y) (x.a == y.a) && (x.b < y.b) , {a}, {b}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	896 %! "UniformOutput", true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	897 %! assert (A, true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	898 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	899 %! a = struct ("a", 1, "b", 2); b = struct ("a", 1, "b", 3);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	900 %! A = cellfun (@(x,y) (x.a == y.a) && (x.b < y.b) , {a}, {b}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	901 %! "UniformOutput", false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	902 %! assert (A, {true});
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	903 %!test
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	904 %! a = struct ("a", 1, "b", 2); b = struct ("a", 1, "b", 3);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	905 %! A = cellfun (@(x,y) cell2str (x.a, y.a), {a}, {b}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	906 %! "ErrorHandler", @cellfunerror);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	907 %! assert (isfield (A, "identifier"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	908 %! assert (isfield (A, "message"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	909 %! assert (isfield (A, "index"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	910 %! assert (isempty (A.message), false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	911 %! assert (A.index, 1);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	912 %!test %% Overwriting setting of "UniformOutput" true
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	913 %! a = struct ("a", 1, "b", 2); b = struct ("a", 1, "b", 3);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	914 %! A = cellfun (@(x,y) cell2str (x.a, y.a), {a}, {b}, \
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	915 %! "UniformOutput", true, "ErrorHandler", @cellfunerror);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	916 %! assert (isfield (A, "identifier"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	917 %! assert (isfield (A, "message"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	918 %! assert (isfield (A, "index"), true);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	919 %! assert (isempty (A.message), false);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	920 %! assert (A.index, 1);
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	921
63fe023d7898 Added more tests for cellfun. Thomas Treichl <Thomas.Treichl@gmx.net> parents: 8347 diff changeset	922 %% A lot of other tests
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	923 %!error(cellfun(1))
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	924 %!error(cellfun('isclass',1))
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	925 %!error(cellfun('size',1))
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	926 %!error(cellfun(@sin,{[]},'BadParam',false))
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	927 %!error(cellfun(@sin,{[]},'UniformOuput'))
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	928 %!error(cellfun(@sin,{[]},'ErrorHandler'))
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	929 %!assert(cellfun(@sin,{0,1}),sin([0,1]))
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	930 %!assert(cellfun(inline('sin(x)'),{0,1}),sin([0,1]))
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	931 %!assert(cellfun('sin',{0,1}),sin([0,1]))
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	932 %!assert(cellfun('isempty',{1,[]}),[false,true])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	933 %!assert(cellfun('islogical',{false,pi}),[true,false])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	934 %!assert(cellfun('isreal',{1i,1}),[false,true])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	935 %!assert(cellfun('length',{zeros(2,2),1}),[2,1])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	936 %!assert(cellfun('prodofsize',{zeros(2,2),1}),[4,1])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	937 %!assert(cellfun('ndims',{zeros([2,2,2]),1}),[3,2])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	938 %!assert(cellfun('isclass',{zeros([2,2,2]),'test'},'double'),[true,false])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	939 %!assert(cellfun('size',{zeros([1,2,3]),1},1),[1,1])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	940 %!assert(cellfun('size',{zeros([1,2,3]),1},2),[2,1])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	941 %!assert(cellfun('size',{zeros([1,2,3]),1},3),[3,1])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	942 %!assert(cellfun(@atan2,{1,1},{1,2}),[atan2(1,1),atan2(1,2)])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	943 %!assert(cellfun(@atan2,{1,1},{1,2},'UniformOutput',false),{atan2(1,1),atan2(1,2)})
6422 9b982dd07654 [project @ 2007-03-20 21:26:12 by dbateman] dbateman parents: 5989 diff changeset	944 %!assert(cellfun(@sin,{1,2;3,4}),sin([1,2;3,4]))
9b982dd07654 [project @ 2007-03-20 21:26:12 by dbateman] dbateman parents: 5989 diff changeset	945 %!assert(cellfun(@atan2,{1,1;1,1},{1,2;1,2}),atan2([1,1;1,1],[1,2;1,2]))
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	946 %!error(cellfun(@factorial,{-1,3}))
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	947 %!assert(cellfun(@factorial,{-1,3},'ErrorHandler',@(x,y) NaN),[NaN,6])
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	948 %!test
6704 781777998927 [project @ 2007-06-13 05:23:56 by jwe] jwe parents: 6623 diff changeset	949 %! [a,b,c]=cellfun(@fileparts,{fullfile("a","b","c.d"),fullfile("e","f","g.h")},'UniformOutput',false);
781777998927 [project @ 2007-06-13 05:23:56 by jwe] jwe parents: 6623 diff changeset	950 %! assert(a,{fullfile("a","b"),fullfile("e","f")})
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	951 %! assert(b,{'c','g'})
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	952 %! assert(c,{'.d','.h'})
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	953
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	954 */
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	955
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	956 static void
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	957 do_num2cell_helper (const dim_vector& dv,
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	958 const Array<int>& dimv,
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	959 dim_vector& celldv, dim_vector& arraydv,
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	960 Array<int>& perm)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	961 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	962 int dvl = dimv.length ();
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	963 int maxd = dv.length ();
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	964 celldv = dv;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	965 for (int i = 0; i < dvl; i++)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	966 maxd = std::max (maxd, dimv(i));
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	967 if (maxd > dv.length ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	968 celldv.resize (maxd, 1);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	969 arraydv = celldv;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	970
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	971 OCTAVE_LOCAL_BUFFER_INIT (bool, sing, maxd, false);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	972
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	973 perm.clear (maxd);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	974 for (int i = 0; i < dvl; i++)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	975 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	976 int k = dimv(i) - 1;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	977 if (k < 0)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	978 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	979 error ("num2cell: dimension indices must be positive");
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	980 return;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	981 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	982 else if (i > 0 && k < dimv(i-1) - 1)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	983 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	984 error ("num2cell: dimension indices must be strictly increasing");
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	985 return;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	986 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	987
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	988 sing[k] = true;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	989 perm(i) = k;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	990 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	991
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	992 for (int k = 0, i = dvl; k < maxd; k++)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	993 if (! sing[k])
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	994 perm(i++) = k;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	995
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	996 for (int i = 0; i < maxd; i++)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	997 if (sing[i])
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	998 celldv(i) = 1;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	999 else
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1000 arraydv(i) = 1;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1001 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1002
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1003 template<class NDA>
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1004 static Cell
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1005 do_num2cell (const NDA& array, const Array<int>& dimv)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1006 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1007 if (dimv.is_empty ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1008 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1009 Cell retval (array.dims ());
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1010 octave_idx_type nel = array.numel ();
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1011 for (octave_idx_type i = 0; i < nel; i++)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1012 retval.xelem (i) = array(i);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1013
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1014 return retval;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1015 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1016 else
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1017 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1018 dim_vector celldv, arraydv;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1019 Array<int> perm;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1020 do_num2cell_helper (array.dims (), dimv, celldv, arraydv, perm);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1021 if (error_state)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1022 return Cell ();
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1023
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1024 NDA parray = array.permute (perm);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1025
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1026 octave_idx_type nela = arraydv.numel (), nelc = celldv.numel ();
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1027 parray = parray.reshape (dim_vector (nela, nelc));
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1028
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1029 Cell retval (celldv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1030 for (octave_idx_type i = 0; i < nelc; i++)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1031 {
9731 7b9cbaad68d6 extend Array<T> Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	1032 retval.xelem (i) = NDA (parray.column (i).reshape (arraydv));
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1033 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1034
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1035 return retval;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1036 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1037 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1038
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1039
5451 ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1040 DEFUN_DLD (num2cell, args, ,
ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1041 "-- texinfo --\n\
9307 c2923c27c877 Various documentation improvements Rik <rdrider0-list@yahoo.com> parents: 9209 diff changeset	1042 @deftypefn {Loadable Function} {@var{c} =} num2cell (@var{m})\n\
8095 d94a597c94a2 Typo in num2cell's description Thomas Weber <thomas.weber.mail@gmail.com> parents: 7977 diff changeset	1043 @deftypefnx {Loadable Function} {@var{c} =} num2cell (@var{m}, @var{dim})\n\
9307 c2923c27c877 Various documentation improvements Rik <rdrider0-list@yahoo.com> parents: 9209 diff changeset	1044 Convert the matrix @var{m} to a cell array. If @var{dim} is defined, the\n\
5451 ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1045 value @var{c} is of dimension 1 in this dimension and the elements of\n\
ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1046 @var{m} are placed in slices in @var{c}.\n\
5642 2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5544 diff changeset	1047 @seealso{mat2cell}\n\
2618a0750ae6 [project @ 2006-03-06 21:26:48 by jwe] jwe parents: 5544 diff changeset	1048 @end deftypefn")
5451 ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1049 {
ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1050 int nargin = args.length();
ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1051 octave_value retval;
ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1052
ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1053 if (nargin < 1 \|\| nargin > 2)
5823 080c08b192d8 [project @ 2006-05-19 05:32:17 by jwe] jwe parents: 5784 diff changeset	1054 print_usage ();
5451 ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1055 else
ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1056 {
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1057 octave_value array = args(0);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1058 Array<int> dimv;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1059 if (nargin > 1)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1060 dimv = args (1).int_vector_value (true);
5451 ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1061
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1062 if (error_state)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1063 ;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1064 else if (array.is_bool_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1065 retval = do_num2cell (array.bool_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1066 else if (array.is_char_matrix ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1067 retval = do_num2cell (array.char_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1068 else if (array.is_numeric_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1069 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1070 if (array.is_integer_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1071 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1072 if (array.is_int8_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1073 retval = do_num2cell (array.int8_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1074 else if (array.is_int16_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1075 retval = do_num2cell (array.int16_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1076 else if (array.is_int32_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1077 retval = do_num2cell (array.int32_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1078 else if (array.is_int64_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1079 retval = do_num2cell (array.int64_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1080 else if (array.is_uint8_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1081 retval = do_num2cell (array.uint8_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1082 else if (array.is_uint16_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1083 retval = do_num2cell (array.uint16_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1084 else if (array.is_uint32_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1085 retval = do_num2cell (array.uint32_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1086 else if (array.is_uint64_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1087 retval = do_num2cell (array.uint64_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1088 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1089 else if (array.is_complex_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1090 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1091 if (array.is_single_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1092 retval = do_num2cell (array.float_complex_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1093 else
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1094 retval = do_num2cell (array.complex_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1095 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1096 else
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1097 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1098 if (array.is_single_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1099 retval = do_num2cell (array.float_array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1100 else
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1101 retval = do_num2cell (array.array_value (), dimv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1102 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1103 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1104 else if (array.is_cell () \|\| array.is_map ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1105 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1106 dim_vector celldv, arraydv;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1107 Array<int> perm;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1108 do_num2cell_helper (array.dims (), dimv, celldv, arraydv, perm);
5451 ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1109
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1110 if (! error_state)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1111 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1112 // FIXME: this operation may be rather inefficient.
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1113 octave_value parray = array.permute (perm);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1114
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1115 octave_idx_type nela = arraydv.numel (), nelc = celldv.numel ();
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1116 parray = parray.reshape (dim_vector (nela, nelc));
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1117
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1118 Cell retcell (celldv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1119 octave_value_list idx (2);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1120 idx(0) = octave_value::magic_colon_t;
5451 ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1121
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1122 for (octave_idx_type i = 0; i < nelc; i++)
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1123 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1124 idx(1) = i + 1;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1125 octave_value tmp = parray.do_index_op (idx);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1126 retcell(i) = tmp.reshape (arraydv);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1127 }
5451 ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1128
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1129 retval = retcell;
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1130 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1131 }
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1132 else
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1133 gripe_wrong_type_arg ("num2cell", array);
5451 ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1134 }
ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1135
ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1136 return retval;
ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1137 }
ed08548b9054 [project @ 2005-09-15 19:52:50 by jwe] jwe parents: 5307 diff changeset	1138
5988 d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	1139 /*
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	1140
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	1141 %!assert(num2cell([1,2;3,4]),{1,2;3,4})
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	1142 %!assert(num2cell([1,2;3,4],1),{[1;3],[2;4]})
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	1143 %!assert(num2cell([1,2;3,4],2),{[1,2];[3,4]})
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	1144
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	1145 */
d9ce802628e6 [project @ 2006-09-12 21:31:41 by dbateman] dbateman parents: 5829 diff changeset	1146
5784 70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1147 DEFUN_DLD (mat2cell, args, ,
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1148 "-- texinfo --\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1149 @deftypefn {Loadable Function} {@var{b} =} mat2cell (@var{a}, @var{m}, @var{n})\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1150 @deftypefnx {Loadable Function} {@var{b} =} mat2cell (@var{a}, @var{d1}, @var{d2}, @dots{})\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1151 @deftypefnx {Loadable Function} {@var{b} =} mat2cell (@var{a}, @var{r})\n\
9036 58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	1152 Convert the matrix @var{a} to a cell array. If @var{a} is 2-D, then\n\
5784 70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1153 it is required that @code{sum (@var{m}) == size (@var{a}, 1)} and\n\
9036 58604c45ca74 Cleanup of data types related documentation Rik <rdrider0-list@yahoo.com> parents: 8920 diff changeset	1154 @code{sum (@var{n}) == size (@var{a}, 2)}. Similarly, if @var{a} is\n\
5784 70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1155 a multi-dimensional and the number of dimensional arguments is equal\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1156 to the dimensions of @var{a}, then it is required that @code{sum (@var{di})\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1157 == size (@var{a}, i)}.\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1158 \n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1159 Given a single dimensional argument @var{r}, the other dimensional\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1160 arguments are assumed to equal @code{size (@var{a},@var{i})}.\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1161 \n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1162 An example of the use of mat2cell is\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1163 \n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1164 @example\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1165 mat2cell (reshape(1:16,4,4),[3,1],[3,1])\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1166 @result{} @{\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1167 [1,1] =\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1168 \n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1169 1 5 9\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1170 2 6 10\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1171 3 7 11\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1172 \n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1173 [2,1] =\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1174 \n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1175 4 8 12\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1176 \n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1177 [1,2] =\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1178 \n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1179 13\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1180 14\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1181 15\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1182 \n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1183 [2,2] = 16\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1184 @}\n\
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1185 @end example\n\
5829 93785a1b0f97 [project @ 2006-05-23 18:34:10 by jwe] jwe parents: 5823 diff changeset	1186 @seealso{num2cell, cell2mat}\n\
5784 70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1187 @end deftypefn")
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1188 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1189 int nargin = args.length();
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1190 octave_value retval;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1191
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1192 if (nargin < 2)
7038 4482ba9814b7 [project @ 2007-10-19 16:05:48 by jwe] jwe parents: 7017 diff changeset	1193 print_usage ();
5784 70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1194 else
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1195 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1196 dim_vector dv = args(0).dims();
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1197 dim_vector new_dv;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1198 new_dv.resize(dv.length());
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1199
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1200 if (nargin > 2)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1201 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1202 octave_idx_type nmax = -1;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1203
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1204 if (nargin - 1 != dv.length())
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1205 error ("mat2cell: Incorrect number of dimensions");
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1206 else
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1207 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1208 for (octave_idx_type j = 0; j < dv.length(); j++)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1209 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1210 ColumnVector d = ColumnVector (args(j+1).vector_value
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1211 (false, true));
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1212
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1213 if (d.length() < 1)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1214 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1215 error ("mat2cell: dimension can not be empty");
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1216 break;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1217 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1218 else
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1219 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1220 if (nmax < d.length())
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1221 nmax = d.length();
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1222
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1223 for (octave_idx_type i = 1; i < d.length(); i++)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1224 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1225 OCTAVE_QUIT;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1226
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1227 if (d(i) >= 0)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1228 d(i) += d(i-1);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1229 else
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1230 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1231 error ("mat2cell: invalid dimensional argument");
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1232 break;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1233 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1234 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1235
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1236 if (d(0) < 0)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1237 error ("mat2cell: invalid dimensional argument");
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1238
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1239 if (d(d.length() - 1) != dv(j))
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1240 error ("mat2cell: inconsistent dimensions");
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1241
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1242 if (error_state)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1243 break;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1244
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1245 new_dv(j) = d.length();
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1246 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1247 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1248 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1249
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1250 if (! error_state)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1251 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1252 // Construct a matrix with the index values
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1253 Matrix dimargs(nmax, new_dv.length());
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1254 for (octave_idx_type j = 0; j < new_dv.length(); j++)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1255 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1256 OCTAVE_QUIT;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1257
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1258 ColumnVector d = ColumnVector (args(j+1).vector_value
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1259 (false, true));
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1260
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1261 dimargs(0,j) = d(0);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1262 for (octave_idx_type i = 1; i < d.length(); i++)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1263 dimargs(i,j) = dimargs(i-1,j) + d(i);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1264 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1265
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1266
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1267 octave_value_list lst (new_dv.length(), octave_value());
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1268 Cell ret (new_dv);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1269 octave_idx_type nel = new_dv.numel();
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1270 octave_idx_type ntot = 1;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1271
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1272 for (int j = 0; j < new_dv.length()-1; j++)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1273 ntot *= new_dv(j);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1274
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1275 for (octave_idx_type i = 0; i < nel; i++)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1276 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1277 octave_idx_type n = ntot;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1278 octave_idx_type ii = i;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1279 for (octave_idx_type j = new_dv.length() - 1; j >= 0; j--)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1280 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1281 OCTAVE_QUIT;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1282
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1283 octave_idx_type idx = ii / n;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1284 lst (j) = Range((idx == 0 ? 1. : dimargs(idx-1,j)+1.),
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1285 dimargs(idx,j));
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1286 ii = ii % n;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1287 if (j != 0)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1288 n /= new_dv(j-1);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1289 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1290 ret(i) = args(0).do_index_op(lst, 0);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1291 if (error_state)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1292 break;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1293 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1294
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1295 if (!error_state)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1296 retval = ret;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1297 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1298 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1299 else
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1300 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1301 ColumnVector d = ColumnVector (args(1).vector_value
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1302 (false, true));
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1303
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1304 double sumd = 0.;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1305 for (octave_idx_type i = 0; i < d.length(); i++)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1306 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1307 OCTAVE_QUIT;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1308
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1309 if (d(i) >= 0)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1310 sumd += d(i);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1311 else
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1312 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1313 error ("mat2cell: invalid dimensional argument");
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1314 break;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1315 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1316 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1317
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1318 if (sumd != dv(0))
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1319 error ("mat2cell: inconsistent dimensions");
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1320
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1321 new_dv(0) = d.length();
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1322 for (octave_idx_type i = 1; i < dv.length(); i++)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1323 new_dv(i) = 1;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1324
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1325 if (! error_state)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1326 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1327 octave_value_list lst (new_dv.length(), octave_value());
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1328 Cell ret (new_dv);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1329
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1330 for (octave_idx_type i = 1; i < new_dv.length(); i++)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1331 lst (i) = Range (1., static_cast<double>(dv(i)));
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1332
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1333 double idx = 0.;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1334 for (octave_idx_type i = 0; i < new_dv(0); i++)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1335 {
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1336 OCTAVE_QUIT;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1337
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1338 lst(0) = Range(idx + 1., idx + d(i));
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1339 ret(i) = args(0).do_index_op(lst, 0);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1340 idx += d(i);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1341 if (error_state)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1342 break;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1343 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1344
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1345 if (!error_state)
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1346 retval = ret;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1347 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1348 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1349 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1350
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1351 return retval;
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1352 }
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1353
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1354 /*
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1355
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1356 %!test
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1357 %! x = reshape(1:20,5,4);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1358 %! c = mat2cell(x,[3,2],[3,1]);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1359 %! assert(c,{[1,6,11;2,7,12;3,8,13],[16;17;18];[4,9,14;5,10,15],[19;20]})
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1360
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1361 %!test
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1362 %! x = 'abcdefghij';
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1363 %! c = mat2cell(x,1,[0,4,2,0,4,0]);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1364 %! empty1by0str = resize('',1,0);
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1365 %! assert(c,{empty1by0str,'abcd','ef',empty1by0str,'ghij',empty1by0str})
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1366
70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1367 */
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1368
9740 78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1369 // FIXME: it would be nice to allow ranges being handled without a conversion.
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1370 template <class NDA>
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1371 static Cell
9740 78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1372 do_cellslices_nda (const NDA& array,
78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1373 const Array<octave_idx_type>& lb,
78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1374 const Array<octave_idx_type>& ub)
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1375 {
9740 78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1376 octave_idx_type n = lb.length ();
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1377 Cell retval (1, n);
9057 8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1378 if (array.is_vector ())
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1379 {
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1380 for (octave_idx_type i = 0; i < n && ! error_state; i++)
9740 78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1381 retval(i) = array.index (idx_vector (lb(i) - 1, ub(i)));
9057 8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1382 }
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1383 else
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1384 {
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1385 dim_vector dv = array.dims ();
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1386 octave_idx_type nl = 1;
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1387 for (int i = 0; i < dv.length () - 1; i++) nl *= dv(i);
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1388 for (octave_idx_type i = 0; i < n && ! error_state; i++)
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1389 {
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1390 // Do it with a single index to speed things up.
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1391 dv = array.dims ();
9057 8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1392 dv(dv.length () - 1) = ub(i) + 1 - lb(i);
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1393 dv.chop_trailing_singletons ();
9740 78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1394 retval(i) = array.index (idx_vector (nl(lb(i) - 1), nlub(i))).reshape (dv);
9057 8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1395 }
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1396 }
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1397
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1398 return retval;
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1399 }
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1400
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1401 DEFUN_DLD (cellslices, args, ,
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1402 "-- texinfo --\n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1403 @deftypefn {Loadable Function} {@var{sl} =} cellslices (@var{x}, @var{lb}, @var{ub})\n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1404 Given a vector @var{x}, this function produces a cell array of slices from the vector\n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1405 determined by the index vectors @var{lb}, @var{ub}, for lower and upper bounds, respectively.\n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1406 In other words, it is equivalent to the following code:\n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1407 \n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1408 @example\n\
9064 7c02ec148a3c Check grammar on all .cc files Rik <rdrider0-list@yahoo.com> parents: 9057 diff changeset	1409 @group\n\
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1410 n = length (lb);\n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1411 sl = cell (1, n);\n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1412 for i = 1:length (lb)\n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1413 sl@{i@} = x(lb(i):ub(i));\n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1414 endfor\n\
9064 7c02ec148a3c Check grammar on all .cc files Rik <rdrider0-list@yahoo.com> parents: 9057 diff changeset	1415 @end group\n\
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1416 @end example\n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1417 \n\
9057 8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1418 If @var{X} is a matrix or array, indexing is done along the last dimension.\n\
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1419 @seealso{mat2cell}\n\
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1420 @end deftypefn")
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1421 {
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1422 octave_value retval;
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1423 int nargin = args.length ();
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1424 if (nargin == 3)
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1425 {
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1426 octave_value x = args(0);
9740 78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1427 Array<octave_idx_type> lb = args(1).octave_idx_type_vector_value ();
78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1428 Array<octave_idx_type> ub = args(2).octave_idx_type_vector_value ();
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1429 if (! error_state)
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1430 {
9740 78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1431 if (lb.length () != ub.length ())
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1432 error ("cellslices: the lengths of lb and ub must match");
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1433 else
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1434 {
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1435 Cell retcell;
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1436 if (! x.is_sparse_type () && x.is_matrix_type ())
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1437 {
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1438 // specialize for some dense arrays.
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1439 if (x.is_bool_type ())
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1440 retcell = do_cellslices_nda (x.bool_array_value (), lb, ub);
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1441 else if (x.is_char_matrix ())
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1442 retcell = do_cellslices_nda (x.char_array_value (), lb, ub);
9678 c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1443 else if (x.is_integer_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1444 {
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1445 if (x.is_int8_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1446 retcell = do_cellslices_nda (x.int8_array_value (), lb, ub);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1447 else if (x.is_int16_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1448 retcell = do_cellslices_nda (x.int16_array_value (), lb, ub);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1449 else if (x.is_int32_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1450 retcell = do_cellslices_nda (x.int32_array_value (), lb, ub);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1451 else if (x.is_int64_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1452 retcell = do_cellslices_nda (x.int64_array_value (), lb, ub);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1453 else if (x.is_uint8_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1454 retcell = do_cellslices_nda (x.uint8_array_value (), lb, ub);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1455 else if (x.is_uint16_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1456 retcell = do_cellslices_nda (x.uint16_array_value (), lb, ub);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1457 else if (x.is_uint32_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1458 retcell = do_cellslices_nda (x.uint32_array_value (), lb, ub);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1459 else if (x.is_uint64_type ())
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1460 retcell = do_cellslices_nda (x.uint64_array_value (), lb, ub);
c929f09457b7 rewrite num2cell for speed-up + a few associated fixes Jaroslav Hajek <highegg@gmail.com> parents: 9622 diff changeset	1461 }
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1462 else if (x.is_complex_type ())
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1463 {
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1464 if (x.is_single_type ())
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1465 retcell = do_cellslices_nda (x.float_complex_array_value (), lb, ub);
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1466 else
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1467 retcell = do_cellslices_nda (x.complex_array_value (), lb, ub);
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1468 }
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1469 else
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1470 {
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1471 if (x.is_single_type ())
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1472 retcell = do_cellslices_nda (x.float_array_value (), lb, ub);
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1473 else
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1474 retcell = do_cellslices_nda (x.array_value (), lb, ub);
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1475 }
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1476 }
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1477 else
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1478 {
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1479 // generic code.
9740 78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1480 octave_idx_type n = lb.length ();
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1481 retcell = Cell (1, n);
9057 8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1482 octave_idx_type nind = x.dims ().is_vector () ? 1 : x.ndims ();
8b263623d0f3 have cellslices index the last dim of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 9042 diff changeset	1483 octave_value_list idx (nind, octave_value::magic_colon_t);
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1484 for (octave_idx_type i = 0; i < n && ! error_state; i++)
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1485 {
9740 78ac37d73557 fix cellslices to handle empty ranges with non-positive bounds Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	1486 idx(nind-1) = Range (lb(i), ub(i));
8985 193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1487 retcell(i) = x.do_index_op (idx);
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1488 }
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1489 }
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1490 if (! error_state)
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1491 retval = retcell;
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1492 }
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1493 }
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1494 }
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1495 else
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1496 print_usage ();
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1497
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1498 return retval;
193804a4f82f add cellslices function Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	1499 }
5784 70f7659d0fb9 [project @ 2006-05-03 05:55:56 by dbateman] dbateman parents: 5642 diff changeset	1500
5205 59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	1501 /*
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	1502 ;;; Local Variables: ***
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	1503 ;;; mode: C++ ***
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	1504 ;;; End: ***
59592dcbb5d8 [project @ 2005-03-15 16:04:56 by jwe] jwe parents: diff changeset	1505 */

Mercurial > octave-nkf

annotate src/DLD-FUNCTIONS/cellfun.cc @ 10043:7fbdeaa9b0e0