octave-nkf: liboctave/array/Array.h annotate

annotate liboctave/array/Array.h @ 20068:19755f4fc851

maint: Cleanup C++ code to follow Octave coding conventions. Try to wrap long lines to < 80 characters. Use GNU style and don't indent first brace of function definition. "case" statement is aligned flush left with brace of switch stmt. Remove trailing '\' line continuation from the end of #define macros. Use 2 spaces for indent. * files-dock-widget.cc, history-dock-widget.cc, main-window.cc, octave-cmd.cc, octave-dock-widget.cc, octave-gui.cc, resource-manager.cc, settings-dialog.cc, shortcut-manager.cc, welcome-wizard.cc, workspace-view.cc, cellfun.cc, data.cc, debug.cc, debug.h, dirfns.cc, error.h, file-io.cc, gl-render.cc, gl-render.h, gl2ps-renderer.h, graphics.cc, graphics.in.h, help.cc, input.cc, load-path.cc, load-path.h, lookup.cc, lu.cc, oct-stream.cc, octave-default-image.h, ordschur.cc, pr-output.cc, qz.cc, strfns.cc, symtab.cc, symtab.h, sysdep.cc, variables.cc, zfstream.h, __fltk_uigetfile__.cc, __init_fltk__.cc, __magick_read__.cc, __osmesa_print__.cc, audiodevinfo.cc, ov-classdef.cc, ov-classdef.h, ov-fcn.h, ov-float.cc, ov-flt-complex.cc, ov-java.cc, ov-range.cc, ov-re-mat.cc, ov-usr-fcn.h, ov.cc, op-int.h, options-usage.h, pt-eval.cc, Array-C.cc, Array-fC.cc, Array.cc, Array.h, PermMatrix.cc, Sparse.cc, chMatrix.h, dSparse.cc, dim-vector.h, bsxfun-decl.h, bsxfun-defs.cc, oct-norm.cc, Sparse-op-defs.h, oct-inttypes.cc, oct-inttypes.h, main.in.cc, mkoctfile.in.cc: Cleanup C++ code to follow Octave coding conventions.

author	Rik <rik@octave.org>
date	Wed, 25 Feb 2015 11:55:49 -0800
parents	4197fc428c7d
children	6af35d4f1ba4

rev	line source
1993 1b57120c997b [project @ 1996-03-03 01:16:15 by jwe] jwe parents: 1989 diff changeset	1 // Template array classes
228 ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	2 /*
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	3
19898 4197fc428c7d maint: Update copyright notices for 2015. John W. Eaton <jwe@octave.org> parents: 19576 diff changeset	4 Copyright (C) 1993-2015 John W. Eaton
11523 fd0a3ac60b0e update copyright notices John W. Eaton <jwe@octave.org> parents: 11507 diff changeset	5 Copyright (C) 2008-2009 Jaroslav Hajek
10521 4d1fc073fbb7 add some missing copyright stmts Jaroslav Hajek <highegg@gmail.com> parents: 10366 diff changeset	6 Copyright (C) 2010 VZLU Prague
228 ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	7
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	8 This file is part of Octave.
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	9
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	10 Octave is free software; you can redistribute it and/or modify it
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	11 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: 6884 diff changeset	12 Free Software Foundation; either version 3 of the License, or (at your
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 6884 diff changeset	13 option) any later version.
228 ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	14
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	15 Octave is distributed in the hope that it will be useful, but WITHOUT
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	18 for more details.
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	19
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	20 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: 6884 diff changeset	21 along with Octave; see the file COPYING. If not, see
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 6884 diff changeset	22 <http://www.gnu.org/licenses/>.
228 ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	23
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	24 */
ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	25
382 e02d6b664394 [project @ 1994-03-09 21:08:03 by jwe] jwe parents: 376 diff changeset	26 #if !defined (octave_Array_h)
e02d6b664394 [project @ 1994-03-09 21:08:03 by jwe] jwe parents: 376 diff changeset	27 #define octave_Array_h 1
e02d6b664394 [project @ 1994-03-09 21:08:03 by jwe] jwe parents: 376 diff changeset	28
1366 f75432dff006 [project @ 1995-09-05 23:56:42 by jwe] jwe parents: 1359 diff changeset	29 #include <cassert>
4152 f14251d33b01 [project @ 2002-11-06 18:41:50 by jwe] jwe parents: 4066 diff changeset	30 #include <cstddef>
3613 0a93682f89c8 [project @ 2000-03-17 10:58:25 by jwe] jwe parents: 3585 diff changeset	31
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8503 diff changeset	32 #include <algorithm>
8950 d865363208d6 include <iosfwd> instead of <iostream> in header files John W. Eaton <jwe@octave.org> parents: 8920 diff changeset	33 #include <iosfwd>
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	34
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	35 #include "dim-vector.h"
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	36 #include "idx-vector.h"
8725 d5af326a3ede [mq]: sort-traits John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	37 #include "lo-traits.h"
3613 0a93682f89c8 [project @ 2000-03-17 10:58:25 by jwe] jwe parents: 3585 diff changeset	38 #include "lo-utils.h"
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7017 diff changeset	39 #include "oct-sort.h"
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	40 #include "quit.h"
12125 a21a3875ca83 implement a common class for reference counts Jaroslav Hajek <highegg@gmail.com> parents: 11586 diff changeset	41 #include "oct-refcount.h"
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7017 diff changeset	42
19522 1f4455ff2329 Remove deprecated methods in liboctave. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19519 diff changeset	43 //!Handles the reference counting for all the derived classes.
228 ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	44 template <class T>
3585 d9803711e047 [project @ 2000-02-08 04:35:39 by jwe] jwe parents: 3569 diff changeset	45 class
d9803711e047 [project @ 2000-02-08 04:35:39 by jwe] jwe parents: 3569 diff changeset	46 Array
228 ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	47 {
3504 5eef8a2294bd [project @ 2000-02-01 10:06:51 by jwe] jwe parents: 2847 diff changeset	48 protected:
1619 1a35c8c91349 [project @ 1995-11-04 11:07:21 by jwe] jwe parents: 1574 diff changeset	49
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	50 //! The real representation of all arrays.
1735 d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	51 class ArrayRep
d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	52 {
d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	53 public:
d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	54
d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	55 T *data;
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	56 octave_idx_type len;
12125 a21a3875ca83 implement a common class for reference counts Jaroslav Hajek <highegg@gmail.com> parents: 11586 diff changeset	57 octave_refcount<int> count;
1735 d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	58
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	59 ArrayRep (T *d, octave_idx_type l)
19576 af41e41ad28e replace oct-mem.h inline indirections by standard function calls. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19522 diff changeset	60 : data (new T [l]), len (l), count (1)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	61 {
19576 af41e41ad28e replace oct-mem.h inline indirections by standard function calls. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19522 diff changeset	62 std::copy (d, d+l, data);
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	63 }
10364 96ed7c629bbd remove dangerous pointer-acquiring Array ctors Jaroslav Hajek <highegg@gmail.com> parents: 10358 diff changeset	64
96ed7c629bbd remove dangerous pointer-acquiring Array ctors Jaroslav Hajek <highegg@gmail.com> parents: 10358 diff changeset	65 template <class U>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	66 ArrayRep (U *d, octave_idx_type l)
19576 af41e41ad28e replace oct-mem.h inline indirections by standard function calls. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19522 diff changeset	67 : data (new T [l]), len (l), count (1)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	68 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	69 std::copy (d, d+l, data);
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	70 }
1735 d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	71
d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	72 ArrayRep (void) : data (0), len (0), count (1) { }
d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	73
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	74 explicit ArrayRep (octave_idx_type n)
19576 af41e41ad28e replace oct-mem.h inline indirections by standard function calls. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19522 diff changeset	75 : data (new T [n]), len (n), count (1) { }
1735 d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	76
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	77 explicit ArrayRep (octave_idx_type n, const T& val)
19576 af41e41ad28e replace oct-mem.h inline indirections by standard function calls. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19522 diff changeset	78 : data (new T [n]), len (n), count (1)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	79 {
19576 af41e41ad28e replace oct-mem.h inline indirections by standard function calls. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19522 diff changeset	80 std::fill_n (data, n, val);
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	81 }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	82
1735 d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	83 ArrayRep (const ArrayRep& a)
19576 af41e41ad28e replace oct-mem.h inline indirections by standard function calls. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19522 diff changeset	84 : data (new T [a.len]), len (a.len), count (1)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	85 {
19576 af41e41ad28e replace oct-mem.h inline indirections by standard function calls. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19522 diff changeset	86 std::copy (a.data, a.data + a.len, data);
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	87 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	88
19576 af41e41ad28e replace oct-mem.h inline indirections by standard function calls. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19522 diff changeset	89 ~ArrayRep (void) { delete [] data; }
1735 d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	90
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	91 octave_idx_type length (void) const { return len; }
1735 d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	92
4517 b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe] jwe parents: 4513 diff changeset	93 private:
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe] jwe parents: 4513 diff changeset	94
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe] jwe parents: 4513 diff changeset	95 // No assignment!
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe] jwe parents: 4513 diff changeset	96
b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe] jwe parents: 4513 diff changeset	97 ArrayRep& operator = (const ArrayRep& a);
1735 d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	98 };
d2ee993d40cd [project @ 1996-01-12 07:46:09 by jwe] jwe parents: 1703 diff changeset	99
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	100 //--------------------------------------------------------------------
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	101
6884 1cbb8b606d63 [project @ 2007-09-10 20:43:26 by jwe] jwe parents: 6881 diff changeset	102 public:
1cbb8b606d63 [project @ 2007-09-10 20:43:26 by jwe] jwe parents: 6881 diff changeset	103
9556 948795dc1974 make a few Array methods inline Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	104 void make_unique (void)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	105 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	106 if (rep->count > 1)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	107 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	108 ArrayRep *r = new ArrayRep (slice_data, slice_len);
13985 43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC). Michael Goffioul <michael.goffioul@gmail.com> parents: 12125 diff changeset	109
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	110 if (--rep->count == 0)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	111 delete rep;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	112
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	113 rep = r;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	114 slice_data = rep->data;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	115 }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	116 }
238 780cbbc57b7c [project @ 1993-11-30 20:23:04 by jwe] jwe parents: 228 diff changeset	117
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5775 diff changeset	118 typedef T element_type;
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5775 diff changeset	119
10075 84b0725f4b09 return class types by reference in const Array element access functions Jaroslav Hajek <highegg@gmail.com> parents: 9921 diff changeset	120 typedef typename ref_param<T>::type crefT;
84b0725f4b09 return class types by reference in const Array element access functions Jaroslav Hajek <highegg@gmail.com> parents: 9921 diff changeset	121
8725 d5af326a3ede [mq]: sort-traits John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	122 typedef bool (*compare_fcn_type) (typename ref_param<T>::type,
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	123 typename ref_param<T>::type);
8725 d5af326a3ede [mq]: sort-traits John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	124
8524 937921654627 clean up Array and DiagArray2 Jaroslav Hajek <highegg@gmail.com> parents: 8523 diff changeset	125 protected:
4902 bd043a433918 [project @ 2004-06-14 18:46:20 by jwe] jwe parents: 4834 diff changeset	126
11507 c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	127 dim_vector dimensions;
4518 382cb0ed8c14 [project @ 2003-09-20 18:08:40 by jwe] jwe parents: 4517 diff changeset	128
11507 c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	129 typename Array<T>::ArrayRep *rep;
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	130
8531 b01fef323c24 add some explaining comments Jaroslav Hajek <highegg@gmail.com> parents: 8524 diff changeset	131 // Rationale:
b01fef323c24 add some explaining comments Jaroslav Hajek <highegg@gmail.com> parents: 8524 diff changeset	132 // slice_data is a pointer to rep->data, denoting together with slice_len the
b01fef323c24 add some explaining comments Jaroslav Hajek <highegg@gmail.com> parents: 8524 diff changeset	133 // actual portion of the data referenced by this Array<T> object. This allows
b01fef323c24 add some explaining comments Jaroslav Hajek <highegg@gmail.com> parents: 8524 diff changeset	134 // to make shallow copies not only of a whole array, but also of contiguous
b01fef323c24 add some explaining comments Jaroslav Hajek <highegg@gmail.com> parents: 8524 diff changeset	135 // subranges. Every time rep is directly manipulated, slice_data and slice_len
b01fef323c24 add some explaining comments Jaroslav Hajek <highegg@gmail.com> parents: 8524 diff changeset	136 // need to be properly updated.
b01fef323c24 add some explaining comments Jaroslav Hajek <highegg@gmail.com> parents: 8524 diff changeset	137
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8503 diff changeset	138 T* slice_data;
ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8503 diff changeset	139 octave_idx_type slice_len;
ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8503 diff changeset	140
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	141 //! slice constructor
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8503 diff changeset	142 Array (const Array<T>& a, const dim_vector& dv,
ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8503 diff changeset	143 octave_idx_type l, octave_idx_type u)
11507 c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	144 : dimensions (dv), rep(a.rep), slice_data (a.slice_data+l), slice_len (u-l)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	145 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	146 rep->count++;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	147 dimensions.chop_trailing_singletons ();
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	148 }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	149
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	150 private:
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	151
4585 a1ac9ab474a1 [project @ 2003-11-08 06:07:33 by jwe] jwe parents: 4567 diff changeset	152 typename Array<T>::ArrayRep *nil_rep (void) const
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	153 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	154 // NR was originally allocated with new, but that does not seem
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	155 // to be necessary since it will never be deleted. So just use
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	156 // a static object instead.
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	157
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	158 static typename Array<T>::ArrayRep nr;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	159 return &nr;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	160 }
238 780cbbc57b7c [project @ 1993-11-30 20:23:04 by jwe] jwe parents: 228 diff changeset	161
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	162 protected:
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	163
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	164 //! For jit support
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	165 Array (T sdata, octave_idx_type slen, octave_idx_type adims, void *arep)
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	166 : dimensions (adims),
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	167 rep (reinterpret_cast<typename Array<T>::ArrayRep *> (arep)),
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	168 slice_data (sdata), slice_len (slen) { }
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	169
228 ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	170 public:
238 780cbbc57b7c [project @ 1993-11-30 20:23:04 by jwe] jwe parents: 228 diff changeset	171
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	172 //! Empty ctor (0 by 0).
1550 d89532de8e72 [project @ 1995-10-08 01:12:20 by jwe] jwe parents: 1366 diff changeset	173 Array (void)
11507 c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	174 : dimensions (), rep (nil_rep ()), slice_data (rep->data),
c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	175 slice_len (rep->len)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	176 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	177 rep->count++;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	178 }
1550 d89532de8e72 [project @ 1995-10-08 01:12:20 by jwe] jwe parents: 1366 diff changeset	179
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	180 //! nD uninitialized ctor.
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	181 explicit Array (const dim_vector& dv)
11507 c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	182 : dimensions (dv),
c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	183 rep (new typename Array<T>::ArrayRep (dv.safe_numel ())),
c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	184 slice_data (rep->data), slice_len (rep->len)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	185 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	186 dimensions.chop_trailing_singletons ();
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	187 }
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	188
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	189 //! nD initialized ctor.
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	190 explicit Array (const dim_vector& dv, const T& val)
11507 c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	191 : dimensions (dv),
c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	192 rep (new typename Array<T>::ArrayRep (dv.safe_numel ())),
c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	193 slice_data (rep->data), slice_len (rep->len)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	194 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	195 fill (val);
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	196 dimensions.chop_trailing_singletons ();
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	197 }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	198
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	199 //! Reshape constructor.
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	200 Array (const Array<T>& a, const dim_vector& dv);
12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	201
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	202 //! Type conversion case.
4902 bd043a433918 [project @ 2004-06-14 18:46:20 by jwe] jwe parents: 4834 diff changeset	203 template <class U>
bd043a433918 [project @ 2004-06-14 18:46:20 by jwe] jwe parents: 4834 diff changeset	204 Array (const Array<U>& a)
11507 c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	205 : dimensions (a.dims ()),
c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	206 rep (new typename Array<T>::ArrayRep (a.data (), a.length ())),
c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	207 slice_data (rep->data), slice_len (rep->len)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	208 { }
4902 bd043a433918 [project @ 2004-06-14 18:46:20 by jwe] jwe parents: 4834 diff changeset	209
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	210 //! No type conversion case.
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	211 Array (const Array<T>& a)
11507 c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	212 : dimensions (a.dimensions), rep (a.rep), slice_data (a.slice_data),
c3ad80f4ce36 Array.h, Array.cc: more constructor fixes John W. Eaton <jwe@octave.org> parents: 11010 diff changeset	213 slice_len (a.slice_len)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	214 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	215 rep->count++;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	216 }
1550 d89532de8e72 [project @ 1995-10-08 01:12:20 by jwe] jwe parents: 1366 diff changeset	217
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	218 public:
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	219
15216 dd7c37ceb800 avoid GCC warning by declaring Array destructor virtual John W. Eaton <jwe@octave.org> parents: 15212 diff changeset	220 virtual ~Array (void)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	221 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	222 if (--rep->count == 0)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	223 delete rep;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	224 }
228 ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	225
9556 948795dc1974 make a few Array methods inline Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	226 Array<T>& operator = (const Array<T>& a)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	227 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	228 if (this != &a)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	229 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	230 if (--rep->count == 0)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	231 delete rep;
9556 948795dc1974 make a few Array methods inline Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	232
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	233 rep = a.rep;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	234 rep->count++;
9556 948795dc1974 make a few Array methods inline Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	235
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	236 dimensions = a.dimensions;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	237 slice_data = a.slice_data;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	238 slice_len = a.slice_len;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	239 }
9556 948795dc1974 make a few Array methods inline Jaroslav Hajek <highegg@gmail.com> parents: 9546 diff changeset	240
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	241 return *this;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	242 }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	243
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	244 void fill (const T& val);
9624 3fc7272937ce implement Array<T>::clear overloads Jaroslav Hajek <highegg@gmail.com> parents: 9556 diff changeset	245
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9341 diff changeset	246 void clear (void);
9624 3fc7272937ce implement Array<T>::clear overloads Jaroslav Hajek <highegg@gmail.com> parents: 9556 diff changeset	247 void clear (const dim_vector& dv);
3fc7272937ce implement Array<T>::clear overloads Jaroslav Hajek <highegg@gmail.com> parents: 9556 diff changeset	248
3fc7272937ce implement Array<T>::clear overloads Jaroslav Hajek <highegg@gmail.com> parents: 9556 diff changeset	249 void clear (octave_idx_type r, octave_idx_type c)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	250 { clear (dim_vector (r, c)); }
238 780cbbc57b7c [project @ 1993-11-30 20:23:04 by jwe] jwe parents: 228 diff changeset	251
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	252 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	253 //! Number of elements in the array. These are all synonyms.
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8503 diff changeset	254 octave_idx_type capacity (void) const { return slice_len; }
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	255 octave_idx_type length (void) const { return capacity (); }
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	256 octave_idx_type nelem (void) const { return capacity (); }
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	257 octave_idx_type numel (void) const { return nelem (); }
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	258 //@}
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	259
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	260 //! Return the array as a column vector.
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	261 Array<T> as_column (void) const
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	262 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	263 Array<T> retval (*this);
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	264 if (dimensions.length () != 2 \|\| dimensions(1) != 1)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	265 retval.dimensions = dim_vector (numel (), 1);
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	266
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	267 return retval;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	268 }
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	269
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	270 //! Return the array as a row vector.
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	271 Array<T> as_row (void) const
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	272 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	273 Array<T> retval (*this);
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	274 if (dimensions.length () != 2 \|\| dimensions(0) != 1)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	275 retval.dimensions = dim_vector (1, numel ());
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	276
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	277 return retval;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	278 }
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	279
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	280 //! Return the array as a matrix.
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	281 Array<T> as_matrix (void) const
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	282 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	283 Array<T> retval (*this);
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	284 if (dimensions.length () != 2)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	285 retval.dimensions = dimensions.redim (2);
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	286
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	287 return retval;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	288 }
10350 12884915a8e4 merge MArray classes & improve Array interface Jaroslav Hajek <highegg@gmail.com> parents: 10312 diff changeset	289
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	290 //! @name First dimension
19522 1f4455ff2329 Remove deprecated methods in liboctave. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19519 diff changeset	291 //!
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	292 //! Get the first dimension of the array (number of rows)
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	293 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	294 octave_idx_type dim1 (void) const { return dimensions(0); }
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	295 octave_idx_type rows (void) const { return dim1 (); }
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	296 //@}
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	297
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	298 //! @name Second dimension
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	299 //!
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	300 //! Get the second dimension of the array (number of columns)
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	301 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	302 octave_idx_type dim2 (void) const { return dimensions(1); }
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	303 octave_idx_type cols (void) const { return dim2 (); }
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	304 octave_idx_type columns (void) const { return dim2 (); }
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	305 //@}
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	306
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	307 //! @name Third dimension
19522 1f4455ff2329 Remove deprecated methods in liboctave. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19519 diff changeset	308 //!
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	309 //! Get the third dimension of the array (number of pages)
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	310 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	311 octave_idx_type dim3 (void) const { return dimensions(2); }
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	312 octave_idx_type pages (void) const { return dim3 (); }
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	313 //@}
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	314
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	315 size_t byte_size (void) const
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	316 { return static_cast<size_t> (numel ()) * sizeof (T); }
4902 bd043a433918 [project @ 2004-06-14 18:46:20 by jwe] jwe parents: 4834 diff changeset	317
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	318 //! Return a const-reference so that dims ()(i) works efficiently.
9026 6890d411a0b8 adjust some array dim query methods Jaroslav Hajek <highegg@gmail.com> parents: 9025 diff changeset	319 const dim_vector& dims (void) const { return dimensions; }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	320
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	321 //! Chop off leading singleton dimensions
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4530 diff changeset	322 Array<T> squeeze (void) const;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	323
10366 e5ae13b8b2c2 improve Array indexing error messages Jaroslav Hajek <highegg@gmail.com> parents: 10364 diff changeset	324 octave_idx_type compute_index (octave_idx_type i, octave_idx_type j) const;
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	325 octave_idx_type compute_index (octave_idx_type i, octave_idx_type j,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	326 octave_idx_type k) const;
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	327 octave_idx_type compute_index (const Array<octave_idx_type>& ra_idx) const;
4517 b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe] jwe parents: 4513 diff changeset	328
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	329 octave_idx_type compute_index_unchecked (const Array<octave_idx_type>& ra_idx)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	330 const
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	331 { return dimensions.compute_index (ra_idx.data (), ra_idx.length ()); }
10645 8645b7087859 abstract scalar index checking off Array<T> (prep for struct optimizations) Jaroslav Hajek <highegg@gmail.com> parents: 10636 diff changeset	332
2108 2b67abb63030 [project @ 1996-04-30 10:44:17 by jwe] jwe parents: 2049 diff changeset	333 // No checking, even for multiple references, ever.
2b67abb63030 [project @ 1996-04-30 10:44:17 by jwe] jwe parents: 2049 diff changeset	334
15018 3d8ace26c5b4 maint: Use Octave coding conventions for cuddled parentheses in liboctave/. Rik <rik@octave.org> parents: 14981 diff changeset	335 T& xelem (octave_idx_type n) { return slice_data[n]; }
3d8ace26c5b4 maint: Use Octave coding conventions for cuddled parentheses in liboctave/. Rik <rik@octave.org> parents: 14981 diff changeset	336 crefT xelem (octave_idx_type n) const { return slice_data[n]; }
2108 2b67abb63030 [project @ 1996-04-30 10:44:17 by jwe] jwe parents: 2049 diff changeset	337
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	338 T& xelem (octave_idx_type i, octave_idx_type j)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	339 { return xelem (dim1 ()*j+i); }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	340 crefT xelem (octave_idx_type i, octave_idx_type j) const
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	341 { return xelem (dim1 ()*j+i); }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	342
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	343 T& xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	344 { return xelem (i, dim2 ()*k+j); }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11574 diff changeset	345 crefT xelem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	346 { return xelem (i, dim2 ()*k+j); }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	347
6867 83619ae96c1d [project @ 2007-09-06 12:08:44 by dbateman] dbateman parents: 6708 diff changeset	348 T& xelem (const Array<octave_idx_type>& ra_idx)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	349 { return xelem (compute_index_unchecked (ra_idx)); }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	350
10075 84b0725f4b09 return class types by reference in const Array element access functions Jaroslav Hajek <highegg@gmail.com> parents: 9921 diff changeset	351 crefT xelem (const Array<octave_idx_type>& ra_idx) const
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	352 { return xelem (compute_index_unchecked (ra_idx)); }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	353
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	354 // FIXME: would be nice to fix this so that we don't unnecessarily force
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	355 // a copy, but that is not so easy, and I see no clean way to do it.
2006 95e952f72d66 [project @ 1996-03-04 00:33:32 by jwe] jwe parents: 2005 diff changeset	356
10366 e5ae13b8b2c2 improve Array indexing error messages Jaroslav Hajek <highegg@gmail.com> parents: 10364 diff changeset	357 T& checkelem (octave_idx_type n);
e5ae13b8b2c2 improve Array indexing error messages Jaroslav Hajek <highegg@gmail.com> parents: 10364 diff changeset	358 T& checkelem (octave_idx_type i, octave_idx_type j);
e5ae13b8b2c2 improve Array indexing error messages Jaroslav Hajek <highegg@gmail.com> parents: 10364 diff changeset	359 T& checkelem (octave_idx_type i, octave_idx_type j, octave_idx_type k);
e5ae13b8b2c2 improve Array indexing error messages Jaroslav Hajek <highegg@gmail.com> parents: 10364 diff changeset	360 T& checkelem (const Array<octave_idx_type>& ra_idx);
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	361
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	362 T& elem (octave_idx_type n)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	363 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	364 make_unique ();
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	365 return xelem (n);
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	366 }
2306 2fbf9bb1cd7a [project @ 1996-07-09 16:49:03 by jwe] jwe parents: 2109 diff changeset	367
14846 460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists. Rik <octave@nomad.inbox5.com> parents: 14616 diff changeset	368 T& elem (octave_idx_type i, octave_idx_type j) { return elem (dim1 ()*j+i); }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	369
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	370 T& elem (octave_idx_type i, octave_idx_type j, octave_idx_type k)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	371 { return elem (i, dim2 ()*k+j); }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	372
6867 83619ae96c1d [project @ 2007-09-06 12:08:44 by dbateman] dbateman parents: 6708 diff changeset	373 T& elem (const Array<octave_idx_type>& ra_idx)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	374 { return Array<T>::elem (compute_index_unchecked (ra_idx)); }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	375
2306 2fbf9bb1cd7a [project @ 1996-07-09 16:49:03 by jwe] jwe parents: 2109 diff changeset	376 #if defined (BOUNDS_CHECKING)
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	377 T& operator () (octave_idx_type n) { return checkelem (n); }
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	378 T& operator () (octave_idx_type i, octave_idx_type j)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	379 { return checkelem (i, j); }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	380 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	381 { return checkelem (i, j, k); }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	382 T& operator () (const Array<octave_idx_type>& ra_idx)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	383 { return checkelem (ra_idx); }
2306 2fbf9bb1cd7a [project @ 1996-07-09 16:49:03 by jwe] jwe parents: 2109 diff changeset	384 #else
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	385 T& operator () (octave_idx_type n) { return elem (n); }
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	386 T& operator () (octave_idx_type i, octave_idx_type j) { return elem (i, j); }
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	387 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	388 { return elem (i, j, k); }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	389 T& operator () (const Array<octave_idx_type>& ra_idx)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	390 { return elem (ra_idx); }
2006 95e952f72d66 [project @ 1996-03-04 00:33:32 by jwe] jwe parents: 2005 diff changeset	391 #endif
95e952f72d66 [project @ 1996-03-04 00:33:32 by jwe] jwe parents: 2005 diff changeset	392
10366 e5ae13b8b2c2 improve Array indexing error messages Jaroslav Hajek <highegg@gmail.com> parents: 10364 diff changeset	393 crefT checkelem (octave_idx_type n) const;
e5ae13b8b2c2 improve Array indexing error messages Jaroslav Hajek <highegg@gmail.com> parents: 10364 diff changeset	394 crefT checkelem (octave_idx_type i, octave_idx_type j) const;
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	395 crefT checkelem (octave_idx_type i, octave_idx_type j,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	396 octave_idx_type k) const;
10366 e5ae13b8b2c2 improve Array indexing error messages Jaroslav Hajek <highegg@gmail.com> parents: 10364 diff changeset	397 crefT checkelem (const Array<octave_idx_type>& ra_idx) const;
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	398
10075 84b0725f4b09 return class types by reference in const Array element access functions Jaroslav Hajek <highegg@gmail.com> parents: 9921 diff changeset	399 crefT elem (octave_idx_type n) const { return xelem (n); }
2306 2fbf9bb1cd7a [project @ 1996-07-09 16:49:03 by jwe] jwe parents: 2109 diff changeset	400
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	401 crefT elem (octave_idx_type i, octave_idx_type j) const
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	402 { return xelem (i, j); }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	403
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	404 crefT elem (octave_idx_type i, octave_idx_type j, octave_idx_type k) const
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	405 { return xelem (i, j, k); }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	406
10075 84b0725f4b09 return class types by reference in const Array element access functions Jaroslav Hajek <highegg@gmail.com> parents: 9921 diff changeset	407 crefT elem (const Array<octave_idx_type>& ra_idx) const
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	408 { return Array<T>::xelem (compute_index_unchecked (ra_idx)); }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	409
2108 2b67abb63030 [project @ 1996-04-30 10:44:17 by jwe] jwe parents: 2049 diff changeset	410 #if defined (BOUNDS_CHECKING)
10075 84b0725f4b09 return class types by reference in const Array element access functions Jaroslav Hajek <highegg@gmail.com> parents: 9921 diff changeset	411 crefT operator () (octave_idx_type n) const { return checkelem (n); }
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	412 crefT operator () (octave_idx_type i, octave_idx_type j) const
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	413 { return checkelem (i, j); }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	414 crefT operator () (octave_idx_type i, octave_idx_type j,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	415 octave_idx_type k) const
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	416 { return checkelem (i, j, k); }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	417 crefT operator () (const Array<octave_idx_type>& ra_idx) const
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	418 { return checkelem (ra_idx); }
2006 95e952f72d66 [project @ 1996-03-04 00:33:32 by jwe] jwe parents: 2005 diff changeset	419 #else
10075 84b0725f4b09 return class types by reference in const Array element access functions Jaroslav Hajek <highegg@gmail.com> parents: 9921 diff changeset	420 crefT operator () (octave_idx_type n) const { return elem (n); }
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	421 crefT operator () (octave_idx_type i, octave_idx_type j) const
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	422 { return elem (i, j); }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	423 crefT operator () (octave_idx_type i, octave_idx_type j,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	424 octave_idx_type k) const
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	425 { return elem (i, j, k); }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	426 crefT operator () (const Array<octave_idx_type>& ra_idx) const
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	427 { return elem (ra_idx); }
2006 95e952f72d66 [project @ 1996-03-04 00:33:32 by jwe] jwe parents: 2005 diff changeset	428 #endif
95e952f72d66 [project @ 1996-03-04 00:33:32 by jwe] jwe parents: 2005 diff changeset	429
9731 7b9cbaad68d6 extend Array<T> Jaroslav Hajek <highegg@gmail.com> parents: 9725 diff changeset	430 // Fast extractors. All of these produce shallow copies.
7b9cbaad68d6 extend Array<T> Jaroslav Hajek <highegg@gmail.com> parents: 9725 diff changeset	431 // Warning: none of these do check bounds, unless BOUNDS_CHECKING is on!
7b9cbaad68d6 extend Array<T> Jaroslav Hajek <highegg@gmail.com> parents: 9725 diff changeset	432
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	433 //! Extract column: A(:,k+1).
9731 7b9cbaad68d6 extend Array<T> Jaroslav Hajek <highegg@gmail.com> parents: 9725 diff changeset	434 Array<T> column (octave_idx_type k) const;
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	435 //! Extract page: A(:,:,k+1).
9731 7b9cbaad68d6 extend Array<T> Jaroslav Hajek <highegg@gmail.com> parents: 9725 diff changeset	436 Array<T> page (octave_idx_type k) const;
7b9cbaad68d6 extend Array<T> Jaroslav Hajek <highegg@gmail.com> parents: 9725 diff changeset	437
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	438 //! Extract a slice from this array as a column vector: A(:)(lo+1:up).
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	439 //! Must be 0 <= lo && up <= numel. May be up < lo.
9731 7b9cbaad68d6 extend Array<T> Jaroslav Hajek <highegg@gmail.com> parents: 9725 diff changeset	440 Array<T> linear_slice (octave_idx_type lo, octave_idx_type up) const;
7b9cbaad68d6 extend Array<T> Jaroslav Hajek <highegg@gmail.com> parents: 9725 diff changeset	441
10352 a3635bc1ea19 remove Array2 Jaroslav Hajek <highegg@gmail.com> parents: 10350 diff changeset	442 Array<T> reshape (octave_idx_type nr, octave_idx_type nc) const
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	443 { return Array<T> (*this, dim_vector (nr, nc)); }
10352 a3635bc1ea19 remove Array2 Jaroslav Hajek <highegg@gmail.com> parents: 10350 diff changeset	444
9731 7b9cbaad68d6 extend Array<T> Jaroslav Hajek <highegg@gmail.com> parents: 9725 diff changeset	445 Array<T> reshape (const dim_vector& new_dims) const
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	446 { return Array<T> (*this, new_dims); }
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4559 diff changeset	447
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	448 Array<T> permute (const Array<octave_idx_type>& vec, bool inv = false) const;
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5105 diff changeset	449 Array<T> ipermute (const Array<octave_idx_type>& vec) const
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	450 { return permute (vec, true); }
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4587 diff changeset	451
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	452 bool is_square (void) const { return (dim1 () == dim2 ()); }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	453
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4548 diff changeset	454 bool is_empty (void) const { return numel () == 0; }
802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4548 diff changeset	455
9026 6890d411a0b8 adjust some array dim query methods Jaroslav Hajek <highegg@gmail.com> parents: 9025 diff changeset	456 bool is_vector (void) const { return dimensions.is_vector (); }
6890d411a0b8 adjust some array dim query methods Jaroslav Hajek <highegg@gmail.com> parents: 9025 diff changeset	457
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	458 Array<T> transpose (void) const;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7717 diff changeset	459 Array<T> hermitian (T (*fcn) (const T&) = 0) const;
238 780cbbc57b7c [project @ 1993-11-30 20:23:04 by jwe] jwe parents: 228 diff changeset	460
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8503 diff changeset	461 const T *data (void) const { return slice_data; }
228 ee01ac1c7acc [project @ 1993-11-16 09:56:54 by jwe] jwe parents: diff changeset	462
3952 945e8c160191 [project @ 2002-05-23 17:18:12 by jwe] jwe parents: 3944 diff changeset	463 const T *fortran_vec (void) const { return data (); }
945e8c160191 [project @ 2002-05-23 17:18:12 by jwe] jwe parents: 3944 diff changeset	464
238 780cbbc57b7c [project @ 1993-11-30 20:23:04 by jwe] jwe parents: 228 diff changeset	465 T *fortran_vec (void);
1560 27a03373de41 [project @ 1995-10-12 07:22:26 by jwe] jwe parents: 1550 diff changeset	466
9546 1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9341 diff changeset	467 bool is_shared (void) { return rep->count > 1; }
1beb23d2b892 optimize op= in common cases Jaroslav Hajek <highegg@gmail.com> parents: 9341 diff changeset	468
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	469 int ndims (void) const { return dimensions.length (); }
1560 27a03373de41 [project @ 1995-10-12 07:22:26 by jwe] jwe parents: 1550 diff changeset	470
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	471 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	472 //! Indexing without resizing.
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	473 Array<T> index (const idx_vector& i) const;
1560 27a03373de41 [project @ 1995-10-12 07:22:26 by jwe] jwe parents: 1550 diff changeset	474
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	475 Array<T> index (const idx_vector& i, const idx_vector& j) const;
7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	476
7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	477 Array<T> index (const Array<idx_vector>& ia) const;
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	478 //@}
1560 27a03373de41 [project @ 1995-10-12 07:22:26 by jwe] jwe parents: 1550 diff changeset	479
14616 13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	480 virtual T resize_fill_value (void) const;
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	481
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	482 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	483 //! Resizing (with fill).
19522 1f4455ff2329 Remove deprecated methods in liboctave. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19519 diff changeset	484 void resize2 (octave_idx_type nr, octave_idx_type nc, const T& rfv);
1f4455ff2329 Remove deprecated methods in liboctave. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19519 diff changeset	485 void resize2 (octave_idx_type nr, octave_idx_type nc)
14616 13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	486 {
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	487 resize2 (nr, nc, resize_fill_value ());
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	488 }
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	489
19522 1f4455ff2329 Remove deprecated methods in liboctave. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19519 diff changeset	490 void resize1 (octave_idx_type n, const T& rfv);
1f4455ff2329 Remove deprecated methods in liboctave. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19519 diff changeset	491 void resize1 (octave_idx_type n) { resize1 (n, resize_fill_value ()); }
1f4455ff2329 Remove deprecated methods in liboctave. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19519 diff changeset	492
14616 13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	493 void resize (const dim_vector& dv, const T& rfv);
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	494 void resize (const dim_vector& dv) { resize (dv, resize_fill_value ()); }
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	495 //@}
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	496
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	497 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	498 //! Indexing with possible resizing and fill
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	499
20068 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19898 diff changeset	500 // FIXME: this is really a corner case, that should better be
8333 9238637cb81c style fixes John W. Eaton <jwe@octave.org> parents: 8290 diff changeset	501 // handled directly in liboctinterp.
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	502
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	503
14616 13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	504 Array<T> index (const idx_vector& i, bool resize_ok, const T& rfv) const;
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	505 Array<T> index (const idx_vector& i, bool resize_ok) const
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	506 {
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	507 return index (i, resize_ok, resize_fill_value ());
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	508 }
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	509
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	510 Array<T> index (const idx_vector& i, const idx_vector& j, bool resize_ok,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	511 const T& rfv) const;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	512 Array<T> index (const idx_vector& i, const idx_vector& j,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	513 bool resize_ok) const
14616 13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	514 {
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	515 return index (i, j, resize_ok, resize_fill_value ());
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	516 }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	517
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	518 Array<T> index (const Array<idx_vector>& ia, bool resize_ok,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	519 const T& rfv) const;
14616 13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	520 Array<T> index (const Array<idx_vector>& ia, bool resize_ok) const
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	521 {
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	522 return index (ia, resize_ok, resize_fill_value ());
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	523 }
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	524 //@}
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	525
7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	526
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	527 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	528 //! Indexed assignment (always with resize & fill).
14616 13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	529 void assign (const idx_vector& i, const Array<T>& rhs, const T& rfv);
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	530 void assign (const idx_vector& i, const Array<T>& rhs)
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	531 {
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	532 assign (i, rhs, resize_fill_value ());
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	533 }
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	534
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	535 void assign (const idx_vector& i, const idx_vector& j, const Array<T>& rhs,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	536 const T& rfv);
14616 13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	537 void assign (const idx_vector& i, const idx_vector& j, const Array<T>& rhs)
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	538 {
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	539 assign (i, j, rhs, resize_fill_value ());
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	540 }
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	541
14616 13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	542 void assign (const Array<idx_vector>& ia, const Array<T>& rhs, const T& rfv);
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	543 void assign (const Array<idx_vector>& ia, const Array<T>& rhs)
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	544 {
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	545 assign (ia, rhs, resize_fill_value ());
13cc11418393 improve handling of default resize fill value for arrays John W. Eaton <jwe@octave.org> parents: 14557 diff changeset	546 }
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	547 //@}
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	548
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	549 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	550 //! Deleting elements.
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	551
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	552 //! A(I) = [] (with a single subscript)
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	553 void delete_elements (const idx_vector& i);
4530 e8d87fefd144 [project @ 2003-10-07 04:02:04 by jwe] jwe parents: 4518 diff changeset	554
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	555 //! A(:,...,I,...,:) = [] (>= 2 subscripts, one of them is non-colon)
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	556 void delete_elements (int dim, const idx_vector& i);
7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	557
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	558 //! Dispatcher to the above two.
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	559 void delete_elements (const Array<idx_vector>& ia);
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	560 //@}
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	561
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	562 //! Insert an array into another at a specified position. If
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	563 //! size (a) is [d1 d2 ... dN] and idx is [i1 i2 ... iN], this
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	564 //! method is equivalent to x(i1:i1+d1-1, i2:i2+d2-1, ... ,
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	565 //! iN:iN+dN-1) = a.
10115 ed49cef7e005 simplify Array::insert methods Jaroslav Hajek <highegg@gmail.com> parents: 10095 diff changeset	566 Array<T>& insert (const Array<T>& a, const Array<octave_idx_type>& idx);
3928 e8627dc4bdf2 [project @ 2002-05-03 19:56:01 by jwe] jwe parents: 3836 diff changeset	567
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	568 //! This is just a special case for idx = [r c 0 ...]
8290 7cbe01c21986 improve dense array indexing Jaroslav Hajek <highegg@gmail.com> parents: 8179 diff changeset	569 Array<T>& insert (const Array<T>& a, octave_idx_type r, octave_idx_type c);
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3928 diff changeset	570
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8503 diff changeset	571 void maybe_economize (void)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	572 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	573 if (rep->count == 1 && slice_len != rep->len)
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	574 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	575 ArrayRep *new_rep = new ArrayRep (slice_data, slice_len);
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	576 delete rep;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	577 rep = new_rep;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	578 slice_data = rep->data;
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	579 }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	580 }
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8503 diff changeset	581
4517 b4449b1193ac [project @ 2003-09-20 02:06:06 by jwe] jwe parents: 4513 diff changeset	582 void print_info (std::ostream& os, const std::string& prefix) const;
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5775 diff changeset	583
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	584 //! Give a pointer to the data in mex format. Unsafe. This function
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	585 //! exists to support the MEX interface. You should not use it
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	586 //! anywhere else.
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5775 diff changeset	587 void mex_get_data (void) const { return const_cast<T > (data ()); }
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7017 diff changeset	588
9725 aea3a3a950e1 implement nth_element Jaroslav Hajek <highegg@gmail.com> parents: 9653 diff changeset	589 Array<T> sort (int dim = 0, sortmode mode = ASCENDING) const;
aea3a3a950e1 implement nth_element Jaroslav Hajek <highegg@gmail.com> parents: 9653 diff changeset	590 Array<T> sort (Array<octave_idx_type> &sidx, int dim = 0,
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	591 sortmode mode = ASCENDING) const;
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	592
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	593 //! Ordering is auto-detected or can be specified.
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8700 diff changeset	594 sortmode is_sorted (sortmode mode = UNSORTED) const;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8700 diff changeset	595
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	596 //! Sort by rows returns only indices.
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8700 diff changeset	597 Array<octave_idx_type> sort_rows_idx (sortmode mode = ASCENDING) const;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8700 diff changeset	598
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	599 //! Ordering is auto-detected or can be specified.
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8700 diff changeset	600 sortmode is_sorted_rows (sortmode mode = UNSORTED) const;
e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8700 diff changeset	601
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	602 //! @brief Do a binary lookup in a sorted array. Must not contain NaNs.
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	603 //! Mode can be specified or is auto-detected by comparing 1st and last element.
8814 de16ebeef93d improve lookup, provide Array<T>::lookup Jaroslav Hajek <highegg@gmail.com> parents: 8725 diff changeset	604 octave_idx_type lookup (const T& value, sortmode mode = UNSORTED) const;
de16ebeef93d improve lookup, provide Array<T>::lookup Jaroslav Hajek <highegg@gmail.com> parents: 8725 diff changeset	605
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	606 //! Ditto, but for an array of values, specializing on the case when values
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	607 //! are sorted. NaNs get the value N.
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	608 Array<octave_idx_type> lookup (const Array<T>& values,
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	609 sortmode mode = UNSORTED) const;
9341 9fd5c56ce57a extend lookup capabilities Jaroslav Hajek <highegg@gmail.com> parents: 9201 diff changeset	610
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	611 //! Count nonzero elements.
9878 ead4f9c82a9a implement Array<T>::nnz Jaroslav Hajek <highegg@gmail.com> parents: 9840 diff changeset	612 octave_idx_type nnz (void) const;
ead4f9c82a9a implement Array<T>::nnz Jaroslav Hajek <highegg@gmail.com> parents: 9840 diff changeset	613
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	614 //! Find indices of (at most n) nonzero elements. If n is specified,
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	615 //! backward specifies search from backward.
20068 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19898 diff changeset	616 Array<octave_idx_type> find (octave_idx_type n = -1,
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19898 diff changeset	617 bool backward = false) const;
9025 484756d558d6 add Array<T>::find Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	618
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	619 //! Returns the n-th element in increasing order, using the same
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	620 //! ordering as used for sort. n can either be a scalar index or a
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	621 //! contiguous range.
9725 aea3a3a950e1 implement nth_element Jaroslav Hajek <highegg@gmail.com> parents: 9653 diff changeset	622 Array<T> nth_element (const idx_vector& n, int dim = 0) const;
aea3a3a950e1 implement nth_element Jaroslav Hajek <highegg@gmail.com> parents: 9653 diff changeset	623
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	624 //! Get the kth super or subdiagonal. The zeroth diagonal is the
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	625 //! ordinary diagonal.
7620 36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7503 diff changeset	626 Array<T> diag (octave_idx_type k = 0) const;
36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7503 diff changeset	627
14557 e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	628 Array<T> diag (octave_idx_type m, octave_idx_type n) const;
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14138 diff changeset	629
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	630 //! Concatenation along a specified (0-based) dimension, equivalent
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	631 //! to cat(). dim = -1 corresponds to dim = 0 and dim = -2
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	632 //! corresponds to dim = 1, but apply the looser matching rules of
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	633 //! vertcat/horzcat.
10531 2dd8ea8bfd71 basic cat functionality in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10521 diff changeset	634 static Array<T>
2dd8ea8bfd71 basic cat functionality in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10521 diff changeset	635 cat (int dim, octave_idx_type n, const Array<T> *array_list);
2dd8ea8bfd71 basic cat functionality in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 10521 diff changeset	636
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	637 //! Apply function fcn to each element of the Array<T>. This function
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	638 //! is optimised with a manually unrolled loop.
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	639 template <class U, class F>
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	640 Array<U>
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	641 map (F fcn) const
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	642 {
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	643 octave_idx_type len = length ();
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	644
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	645 const T *m = data ();
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	646
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	647 Array<U> result (dims ());
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	648 U *p = result.fortran_vec ();
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	649
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	650 octave_idx_type i;
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	651 for (i = 0; i < len - 3; i += 4)
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	652 {
10312 cbc402e64d83 untabify liboctave header files John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	653 octave_quit ();
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	654
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	655 p[i] = fcn (m[i]);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	656 p[i+1] = fcn (m[i+1]);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	657 p[i+2] = fcn (m[i+2]);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	658 p[i+3] = fcn (m[i+3]);
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	659 }
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	660
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 10115 diff changeset	661 octave_quit ();
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	662
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	663 for (; i < len; i++)
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	664 p[i] = fcn (m[i]);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	665
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	666 return result;
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7463 diff changeset	667 }
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8950 diff changeset	668
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	669 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	670 //! Overloads for function references.
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	671 template <class U>
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	672 Array<U>
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	673 map (U (&fcn) (T)) const
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	674 { return map<U, U (&) (T)> (fcn); }
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	675
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	676 template <class U>
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	677 Array<U>
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	678 map (U (&fcn) (const T&)) const
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	679 { return map<U, U (&) (const T&)> (fcn); }
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	680 //@}
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	681
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	682 //! Generic any/all test functionality with arbitrary predicate.
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	683 template <class F, bool zero>
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	684 bool test (F fcn) const
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	685 {
15212 4bbd3bbb8912 reduce code duplication in too_large_for_float array functions John W. Eaton <jwe@octave.org> parents: 15018 diff changeset	686 return any_all_test<F, T, zero> (fcn, data (), length ());
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	687 }
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	688
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	689 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	690 //! Simpler calls.
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	691 template <class F>
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	692 bool test_any (F fcn) const
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	693 { return test<F, false> (fcn); }
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	694
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	695 template <class F>
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	696 bool test_all (F fcn) const
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	697 { return test<F, true> (fcn); }
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	698 //@}
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	699
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	700 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	701 //! Overloads for function references.
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	702 bool test_any (bool (&fcn) (T)) const
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	703 { return test<bool (&) (T), false> (fcn); }
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	704
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	705 bool test_any (bool (&fcn) (const T&)) const
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	706 { return test<bool (&) (const T&), false> (fcn); }
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	707
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	708 bool test_all (bool (&fcn) (T)) const
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	709 { return test<bool (&) (T), true> (fcn); }
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	710
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	711 bool test_all (bool (&fcn) (const T&)) const
9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	712 { return test<bool (&) (const T&), true> (fcn); }
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	713 //@}
11010 9478b216752e simplify more array tests Jaroslav Hajek <highegg@gmail.com> parents: 10716 diff changeset	714
9046 88bf56bbccca make Array::find already return Matlab-compatible dimensions Jaroslav Hajek <highegg@gmail.com> parents: 9026 diff changeset	715 template <class U> friend class Array;
9201 472f0e22aa60 guard against implicit instantiation Jaroslav Hajek <highegg@gmail.com> parents: 9046 diff changeset	716
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	717 //! Returns true if this->dims () == dv, and if so, replaces this->dimensions
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	718 //! by a shallow copy of dv. This is useful for maintaining several arrays with
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	719 //! supposedly equal dimensions (e.g. structs in the interpreter).
10674 e3064439d6b4 new Array method for internal use Jaroslav Hajek <highegg@gmail.com> parents: 10673 diff changeset	720 bool optimize_dimensions (const dim_vector& dv);
e3064439d6b4 new Array method for internal use Jaroslav Hajek <highegg@gmail.com> parents: 10673 diff changeset	721
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	722 //@{
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	723 //! WARNING: Only call these functions from jit
19522 1f4455ff2329 Remove deprecated methods in liboctave. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 19519 diff changeset	724
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	725 int *jit_ref_count (void) { return rep->count.get (); }
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	726
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	727 T *jit_slice_data (void) const { return slice_data; }
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	728
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	729 octave_idx_type *jit_dimensions (void) const { return dimensions.to_jit (); }
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	730
4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	731 void *jit_array_rep (void) const { return rep; }
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	732 //@}
14951 4c9fd3e31436 Start of jit support for double matricies Max Brister <max@2bass.com> parents: 14616 diff changeset	733
9201 472f0e22aa60 guard against implicit instantiation Jaroslav Hajek <highegg@gmail.com> parents: 9046 diff changeset	734 private:
472f0e22aa60 guard against implicit instantiation Jaroslav Hajek <highegg@gmail.com> parents: 9046 diff changeset	735 static void instantiation_guard ();
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4461 diff changeset	736 };
4459 75ee1995d2b4 [project @ 2003-07-11 17:46:41 by jwe] jwe parents: 4192 diff changeset	737
19198 96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	738 //! This is a simple wrapper template that will subclass an Array<T>
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	739 //! type or any later type derived from it and override the default
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	740 //! non-const operator() to not check for the array's uniqueness. It
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	741 //! is, however, the user's responsibility to ensure the array is
96751a74bbbb Start doxygenising sources Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 17769 diff changeset	742 //! actually unaliased whenever elements are accessed.
9653 e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	743 template<class ArrayClass>
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	744 class NoAlias : public ArrayClass
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	745 {
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	746 typedef typename ArrayClass::element_type T;
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	747 public:
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	748 NoAlias () : ArrayClass () { }
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	749
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	750 // FIXME: this would be simpler once C++0x is available
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	751 template <class X>
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	752 explicit NoAlias (X x) : ArrayClass (x) { }
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	753
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	754 template <class X, class Y>
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	755 explicit NoAlias (X x, Y y) : ArrayClass (x, y) { }
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	756
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	757 template <class X, class Y, class Z>
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	758 explicit NoAlias (X x, Y y, Z z) : ArrayClass (x, y, z) { }
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	759
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	760 T& operator () (octave_idx_type n)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	761 { return ArrayClass::xelem (n); }
9653 e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	762 T& operator () (octave_idx_type i, octave_idx_type j)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	763 { return ArrayClass::xelem (i, j); }
9653 e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	764 T& operator () (octave_idx_type i, octave_idx_type j, octave_idx_type k)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	765 { return ArrayClass::xelem (i, j, k); }
9653 e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	766 T& operator () (const Array<octave_idx_type>& ra_idx)
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	767 { return ArrayClass::xelem (ra_idx); }
9653 e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	768 };
e087d7c77ff9 improve linspace in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9624 diff changeset	769
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	770 template <class T>
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	771 std::ostream&
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	772 operator << (std::ostream& os, const Array<T>& a);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9731 diff changeset	773
9773 01f897d8a130 optimize memory manipulation by arrays & indexing Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	774 #endif

Mercurial > hg > octave-nkf

annotate liboctave/array/Array.h @ 20068:19755f4fc851