Re: [Pkg-octave-devel] Bug#656467: Bug#656467: octave-fixed: mark_as_command is obsolete
2012/1/19 Svante Signell <svante.signell@telia.com>:
> On Thu, 2012-01-19 at 11:03 -0500, Jordi Gutiérrez Hermoso wrote:
>> Great, are you gonna help me compile it? How much C++ do you know? If
>> you can't give code, how much can you pay to keep it alive? I think
>> some 40 EUR would go a long way to motivate me again to fix the
>> compilation issues if someone else doesn't beat me to it.
>>
>> Octave 3.4.3 has been uploaded to experimental and 3.6.0 has already
>> been released. The fixed package doesn't compile with either of those.
>> I tried to fix it the other day, but got tangled in a mess of template
>> errors and gave up after it seemed like too much work for a package I
>> don't even personally use, but I understand others might.
>
> Maybe I can help trying to compile it. What do I need to install to get
> the environment for a build? I'll go for octave 3.4.3 to start with
> already available for Debian.
You should start from the svn tree for Octave-Forge. Note that the
fixed package isn't distributed anymore by Octave-Forge, but it's
still in its svn tree. The build-deps for Octave should be sufficient
for the fixed package as well.
The problem is that the API has changed, so many calls of the form
Array x(size_1, size_2)
should now be
Array x(dim_vector(size_1, size_2));
The MArrayN and MArray2 classes have also been removed.
I attach you the diff of changes I have so far (sorry it has a bunch
of whitespace changes too), if you want to start from this.
- Jordi G. H.
Index: doc/Makefile
===================================================================
--- doc/Makefile (revision 9213)
+++ doc/Makefile (working copy)
@@ -5,7 +5,7 @@
MKDOC = ../../../admin/mkdoc
MKTEXI = ../../../admin/mktexi
MAKEINFO = makeinfo --no-split
-TEXI2PDF = texi2ppf --clean
+TEXI2PDF = texi2pdf --clean
DVIPS = dvips
LN_S = ln -s
endif
Index: src/int/fixed.cc
===================================================================
--- src/int/fixed.cc (revision 9213)
+++ src/int/fixed.cc (working copy)
@@ -1178,7 +1178,7 @@
*/
fp_uint i = num >> x.decsize;
- fp_uint d = (num & ((x.filter >> x.intsize+1) & x.filter));
+ fp_uint d = (num & ((x.filter >> (x.intsize+1)) & x.filter));
/*
Print sign.
Index: src/fixedRowVector.cc
===================================================================
--- src/fixedRowVector.cc (revision 9213)
+++ src/fixedRowVector.cc (working copy)
@@ -1,26 +1,26 @@
// Fixed Point RowVector manipulations.
/*
-Copyright (C) 2003 Motorola Inc
-Copyright (C) 2003 David Bateman
+ Copyright (C) 2003 Motorola Inc
+ Copyright (C) 2003 David Bateman
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2, or (at your option) any
+ later version.
-This program is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
-You should have received a copy of the GNU General Public License
-along with this program; see the file COPYING. If not, see
-<http://www.gnu.org/licenses/>.
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING. If not, see
+ <http://www.gnu.org/licenses/>.
-In addition to the terms of the GPL, you are permitted to link
-this program with any Open Source program, as defined by the
-Open Source Initiative (www.opensource.org)
+ In addition to the terms of the GPL, you are permitted to link
+ this program with any Open Source program, as defined by the
+ Open Source Initiative (www.opensource.org)
*/
@@ -40,7 +40,7 @@
// Fixed Point Row Vector class
FixedRowVector::FixedRowVector (const MArray<int> &is, const MArray<int> &ds)
- : MArray<FixedPoint> (is.length())
+ : MArray<FixedPoint> (dim_vector (1, is.length()))
{
if (length() != ds.length()) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -52,7 +52,7 @@
}
FixedRowVector::FixedRowVector (const RowVector &is, const RowVector &ds)
- : MArray<FixedPoint> (is.length())
+ : MArray<FixedPoint> (dim_vector (1, is.length()))
{
if (length() != ds.length()) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -63,9 +63,9 @@
elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i));
}
-FixedRowVector::FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
- const FixedRowVector& a)
- : MArray<FixedPoint> (a.length())
+FixedRowVector::FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
+ const FixedRowVector& a)
+ : MArray<FixedPoint> (dim_vector (1, a.length()))
{
if ((length() != is.length()) || (length() != ds.length())) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -73,13 +73,13 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ a.elem (i));
}
-FixedRowVector::FixedRowVector (const RowVector &is, const RowVector &ds,
- const FixedRowVector& a)
- : MArray<FixedPoint> (a.length())
+FixedRowVector::FixedRowVector (const RowVector &is, const RowVector &ds,
+ const FixedRowVector& a)
+ : MArray<FixedPoint> (dim_vector (1, a.length()))
{
if ((length() != is.length()) || (length() != ds.length())) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -87,21 +87,21 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ a.elem (i));
}
-FixedRowVector::FixedRowVector (unsigned int is, unsigned int ds,
- const FixedRowVector& a)
- : MArray<FixedPoint> (a.length())
+FixedRowVector::FixedRowVector (unsigned int is, unsigned int ds,
+ const FixedRowVector& a)
+ : MArray<FixedPoint> (dim_vector (1, a.length()))
{
for (int i = 0; i < length (); i++)
elem (i) = FixedPoint(is, ds, a.elem (i));
}
-FixedRowVector::FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
- const RowVector& a)
- : MArray<FixedPoint> (a.length())
+FixedRowVector::FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
+ const RowVector& a)
+ : MArray<FixedPoint> (dim_vector (1, a.length()))
{
if ((length() != is.length()) || (length() != ds.length())) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -109,13 +109,13 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ a.elem (i));
}
-FixedRowVector::FixedRowVector (const RowVector &is, const RowVector &ds,
- const RowVector& a)
- : MArray<FixedPoint> (a.length())
+FixedRowVector::FixedRowVector (const RowVector &is, const RowVector &ds,
+ const RowVector& a)
+ : MArray<FixedPoint> (dim_vector (1, a.length()))
{
if ((length() != is.length()) || (length() != ds.length())) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -123,21 +123,21 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ a.elem (i));
}
-FixedRowVector::FixedRowVector (unsigned int is, unsigned int ds,
- const RowVector& a)
- : MArray<FixedPoint> (a.length())
+FixedRowVector::FixedRowVector (unsigned int is, unsigned int ds,
+ const RowVector& a)
+ : MArray<FixedPoint> (dim_vector (1, a.length()))
{
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint(is, ds, a.elem (i));
+ elem (i) = FixedPoint(is, ds, a.elem (i));
}
-FixedRowVector::FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
- const RowVector& a, const RowVector& b)
- : MArray<FixedPoint> (a.length())
+FixedRowVector::FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
+ const RowVector& a, const RowVector& b)
+ : MArray<FixedPoint> (dim_vector (1, a.length()))
{
if ((length() != b.length()) || (length() != is.length()) ||
(length() != ds.length())) {
@@ -146,14 +146,14 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- (unsigned int)a.elem (i),
- (unsigned int)b.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ (unsigned int)a.elem (i),
+ (unsigned int)b.elem (i));
}
-FixedRowVector::FixedRowVector (const RowVector &is, const RowVector &ds,
- const RowVector& a, const RowVector& b)
- : MArray<FixedPoint> (a.length())
+FixedRowVector::FixedRowVector (const RowVector &is, const RowVector &ds,
+ const RowVector& a, const RowVector& b)
+ : MArray<FixedPoint> (dim_vector (1, a.length()))
{
if ((length() != b.length()) || (length() != is.length()) ||
(length() != ds.length())) {
@@ -162,14 +162,14 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- (unsigned int)a.elem (i),
- (unsigned int)b.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ (unsigned int)a.elem (i),
+ (unsigned int)b.elem (i));
}
-FixedRowVector::FixedRowVector (unsigned int is, unsigned int ds,
- const RowVector& a, const RowVector& b)
- : MArray<FixedPoint> (a.length())
+FixedRowVector::FixedRowVector (unsigned int is, unsigned int ds,
+ const RowVector& a, const RowVector& b)
+ : MArray<FixedPoint> (dim_vector (1, a.length()))
{
if (length() != b.length()) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -177,20 +177,20 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint(is, ds, (unsigned int)a.elem (i),
- (unsigned int)b.elem (i));
+ elem (i) = FixedPoint(is, ds, (unsigned int)a.elem (i),
+ (unsigned int)b.elem (i));
}
-#define GET_FIXED_PROP(METHOD) \
- RowVector \
- FixedRowVector:: METHOD (void) const \
- { \
- int len = length(); \
- RowVector retval(len); \
- for (int i = 0; i < len; i++) \
- retval(i) = (double) elem(i) . METHOD (); \
- return retval; \
- } \
+#define GET_FIXED_PROP(METHOD) \
+ RowVector \
+ FixedRowVector:: METHOD (void) const \
+ { \
+ int len = length(); \
+ RowVector retval(len); \
+ for (int i = 0; i < len; i++) \
+ retval(i) = (double) elem(i) . METHOD (); \
+ return retval; \
+ } \
GET_FIXED_PROP(sign);
GET_FIXED_PROP(signbit);
@@ -201,7 +201,7 @@
#undef GET_FIXED_PROP
-FixedRowVector
+FixedRowVector
FixedRowVector::chdecsize (const double n)
{
int len = length();
@@ -213,7 +213,7 @@
return retval;
}
-FixedRowVector
+FixedRowVector
FixedRowVector::chdecsize (const RowVector &n)
{
int len = length();
@@ -226,12 +226,12 @@
FixedRowVector retval(len);
for (int i = 0; i < len; i++)
- retval(i) = FixedPoint(elem(i).getintsize(), (int)n(i), elem(i));
+ retval(i) = FixedPoint(elem(i).getintsize(), (int)n(i), elem(i));
return retval;
}
-FixedRowVector
+FixedRowVector
FixedRowVector::chintsize (const double n)
{
int len = length();
@@ -243,7 +243,7 @@
return retval;
}
-FixedRowVector
+FixedRowVector
FixedRowVector::chintsize (const RowVector &n)
{
int len = length();
@@ -256,12 +256,12 @@
FixedRowVector retval(len);
for (int i = 0; i < len; i++)
- retval(i) = FixedPoint((int)n(i), elem(i).getdecsize(), elem(i));
+ retval(i) = FixedPoint((int)n(i), elem(i).getdecsize(), elem(i));
return retval;
}
-FixedRowVector
+FixedRowVector
FixedRowVector::incdecsize (const double n) {
return chdecsize(n + getdecsize());
}
@@ -275,12 +275,12 @@
return chdecsize(n + getdecsize());
}
-FixedRowVector
+FixedRowVector
FixedRowVector::incdecsize () {
return chdecsize(1 + getdecsize());
}
-FixedRowVector
+FixedRowVector
FixedRowVector::incintsize (const double n) {
return chintsize(n + getintsize());
}
@@ -294,7 +294,7 @@
return chintsize(n + getintsize());
}
-FixedRowVector
+FixedRowVector
FixedRowVector::incintsize () {
return chintsize(1 + getintsize());
}
@@ -308,10 +308,10 @@
if (len != a.length ())
return 0;
- for (int i = 0; i < len; i++)
- if (elem(i) != a.elem(i))
- return false;
- return true;
+ for (int i = 0; i < len; i++)
+ if (elem(i) != a.elem(i))
+ return false;
+ return true;
}
bool
@@ -326,18 +326,18 @@
int a_len = a.length ();
if (c < 0 || c + a_len > length ())
- {
- (*current_liboctave_error_handler) ("range error for insert");
- return *this;
- }
+ {
+ (*current_liboctave_error_handler) ("range error for insert");
+ return *this;
+ }
if (a_len > 0)
- {
- make_unique ();
+ {
+ make_unique ();
- for (int i = 0; i < a_len; i++)
- xelem (c+i) = a.elem (i);
- }
+ for (int i = 0; i < a_len; i++)
+ xelem (c+i) = a.elem (i);
+ }
return *this;
}
@@ -348,12 +348,12 @@
int len = length ();
if (len > 0)
- {
- make_unique ();
+ {
+ make_unique ();
- for (int i = 0; i < len; i++)
- xelem (i) = val;
- }
+ for (int i = 0; i < len; i++)
+ xelem (i) = val;
+ }
return *this;
}
@@ -364,20 +364,20 @@
int len = length ();
if (c1 < 0 || c2 < 0 || c1 >= len || c2 >= len)
- {
- (*current_liboctave_error_handler) ("range error for fill");
- return *this;
- }
+ {
+ (*current_liboctave_error_handler) ("range error for fill");
+ return *this;
+ }
if (c1 > c2) { int tmp = c1; c1 = c2; c2 = tmp; }
if (c2 >= c1)
- {
- make_unique ();
+ {
+ make_unique ();
- for (int i = c1; i <= c2; i++)
- xelem (i) = val;
- }
+ for (int i = c1; i <= c2; i++)
+ xelem (i) = val;
+ }
return *this;
}
@@ -427,11 +427,11 @@
#define DO_FIXED_VEC_FUNC(FUNC, MT) \
MT FUNC (const FixedRowVector& x) \
- { \
- MT retval (x.length()); \
+ { \
+ MT retval (x.length()); \
for (int i = 0; i < x.length(); i++) \
- retval(i) = FUNC ( x (i) ); \
- return retval; \
+ retval(i) = FUNC ( x (i) ); \
+ return retval; \
}
DO_FIXED_VEC_FUNC(real, FixedRowVector);
@@ -453,33 +453,33 @@
DO_FIXED_VEC_FUNC(floor, FixedRowVector);
DO_FIXED_VEC_FUNC(ceil, FixedRowVector);
-FixedRowVector elem_pow (const FixedRowVector &a,
- const FixedRowVector &b)
+FixedRowVector elem_pow (const FixedRowVector &a,
+ const FixedRowVector &b)
{
FixedRowVector retval;
int a_len = a.length ();
int b_len = b.length ();
if (a_len == 1)
- {
- retval.resize(b_len);
- FixedPoint ad = a(0);
- for (int i = 0; i < b_len; i++)
- retval(i) = pow(ad, b(i));
- }
+ {
+ retval.resize(dim_vector (1, b_len));
+ FixedPoint ad = a(0);
+ for (int i = 0; i < b_len; i++)
+ retval(i) = pow(ad, b(i));
+ }
else if (b_len == 1)
- {
- retval.resize(a_len);
- FixedPoint bd = b(0);
- for (int i = 0; i < a_len; i++)
- retval(i) = pow(a(i), bd);
- }
+ {
+ retval.resize(dim_vector (1, a_len));
+ FixedPoint bd = b(0);
+ for (int i = 0; i < a_len; i++)
+ retval(i) = pow(a(i), bd);
+ }
else if (a_len == b_len)
- {
- retval.resize(a_len);
- for (int i = 0; i < a_len; i++)
- retval(i) = pow(a(i), b(i));
- }
+ {
+ retval.resize(dim_vector (1, a_len));
+ for (int i = 0; i < a_len; i++)
+ retval(i) = pow(a(i), b(i));
+ }
else
gripe_nonconformant ("operator .^", a_len, b_len);
@@ -511,16 +511,16 @@
if (a_nr != len)
gripe_nonconformant ("operator *", 1, len, a_nr, a_nc);
else
- {
- int a_nr = a.rows ();
- int a_nc = a.cols ();
+ {
+ int a_nr = a.rows ();
+ int a_nc = a.cols ();
- retval.resize (a_nc, FixedPoint());
- if (len != 0)
- for (int i = 0; i < a_nc; i++)
- for (int j = 0; j < a_nr; j++)
- retval.elem (i) += v.elem(j) * a.elem(j,i);
- }
+ retval.resize (dim_vector (1, a_nc), FixedPoint());
+ if (len != 0)
+ for (int i = 0; i < a_nc; i++)
+ for (int j = 0; j < a_nr; j++)
+ retval.elem (i) += v.elem(j) * a.elem(j,i);
+ }
return retval;
}
@@ -598,17 +598,17 @@
if (len < 1)
is.clear (std::ios::badbit);
else
+ {
+ FixedPoint tmp;
+ for (int i = 0; i < len; i++)
{
- FixedPoint tmp;
- for (int i = 0; i < len; i++)
- {
- is >> tmp;
- if (is)
- a.elem (i) = tmp;
- else
- break;
- }
+ is >> tmp;
+ if (is)
+ a.elem (i) = tmp;
+ else
+ break;
}
+ }
return is;
}
@@ -626,14 +626,14 @@
if (len != a_len)
gripe_nonconformant ("operator *", len, a_len);
else if (len != 0)
- for (int i = 0; i < len; i++)
+ for (int i = 0; i < len; i++)
retval += v.elem(i) * a.elem(i);
return retval;
}
/*
-;;; Local Variables: ***
-;;; mode: C++ ***
-;;; End: ***
+ ;;; Local Variables: ***
+ ;;; mode: C++ ***
+ ;;; End: ***
*/
Index: src/fixedNDArray.h
===================================================================
--- src/fixedNDArray.h (revision 9213)
+++ src/fixedNDArray.h (working copy)
@@ -26,7 +26,7 @@
#if !defined (octave_FixedNDArray_h)
#define octave_FixedNDArray_h 1
-#include <octave/MArrayN.h>
+#include <octave/MArray.h>
#include <octave/dMatrix.h>
#include <octave/dNDArray.h>
#include <octave/boolNDArray.h>
Index: src/fixedColVector.h
===================================================================
--- src/fixedColVector.h (revision 9213)
+++ src/fixedColVector.h (working copy)
@@ -1,25 +1,25 @@
/*
-Copyright (C) 2003 Motorola Inc
-Copyright (C) 2003 David Bateman
+ Copyright (C) 2003 Motorola Inc
+ Copyright (C) 2003 David Bateman
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2, or (at your option) any
+ later version.
-This program is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
-You should have received a copy of the GNU General Public License
-along with this program; see the file COPYING. If not, see
-<http://www.gnu.org/licenses/>.
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING. If not, see
+ <http://www.gnu.org/licenses/>.
-In addition to the terms of the GPL, you are permitted to link
-this program with any Open Source program, as defined by the
-Open Source Initiative (www.opensource.org)
+ In addition to the terms of the GPL, you are permitted to link
+ this program with any Open Source program, as defined by the
+ Open Source Initiative (www.opensource.org)
*/
@@ -43,46 +43,48 @@
typedef FixedPoint (*fp_fp_Mapper)(FixedPoint);
class
-OCTAVE_FIXED_API
+OCTAVE_FIXED_API
FixedColumnVector : public MArray<FixedPoint>
{
-public:
+ public:
FixedColumnVector (void) : MArray<FixedPoint> () { }
- explicit FixedColumnVector (int n) : MArray<FixedPoint> (n) { }
+ explicit FixedColumnVector (int n)
+ : MArray<FixedPoint> (dim_vector (n, 1)) { }
FixedColumnVector (const MArray<int> &is, const MArray<int> &ds);
FixedColumnVector (const ColumnVector &is, const ColumnVector &ds);
- FixedColumnVector (unsigned int is, unsigned int ds,
- const FixedColumnVector& a);
+ FixedColumnVector (unsigned int is, unsigned int ds,
+ const FixedColumnVector& a);
- FixedColumnVector (const MArray<int> &is, const MArray<int> &ds,
- const FixedColumnVector& a);
+ FixedColumnVector (const MArray<int> &is, const MArray<int> &ds,
+ const FixedColumnVector& a);
- FixedColumnVector (const ColumnVector &is, const ColumnVector &ds,
- const FixedColumnVector& a);
+ FixedColumnVector (const ColumnVector &is, const ColumnVector &ds,
+ const FixedColumnVector& a);
FixedColumnVector (unsigned int is, unsigned int ds, const ColumnVector& a);
- FixedColumnVector (const MArray<int> &is, const MArray<int> &ds,
- const ColumnVector& a);
+ FixedColumnVector (const MArray<int> &is, const MArray<int> &ds,
+ const ColumnVector& a);
- FixedColumnVector (const ColumnVector &is, const ColumnVector &ds,
- const ColumnVector& a);
+ FixedColumnVector (const ColumnVector &is, const ColumnVector &ds,
+ const ColumnVector& a);
- FixedColumnVector (unsigned int is, unsigned int ds, const ColumnVector& a,
- const ColumnVector& b);
+ FixedColumnVector (unsigned int is, unsigned int ds, const ColumnVector& a,
+ const ColumnVector& b);
- FixedColumnVector (const MArray<int> &is, const MArray<int> &ds,
- const ColumnVector& a, const ColumnVector& b);
+ FixedColumnVector (const MArray<int> &is, const MArray<int> &ds,
+ const ColumnVector& a, const ColumnVector& b);
- FixedColumnVector (const ColumnVector &is, const ColumnVector &ds,
- const ColumnVector& a, const ColumnVector& b);
+ FixedColumnVector (const ColumnVector &is, const ColumnVector &ds,
+ const ColumnVector& a, const ColumnVector& b);
- FixedColumnVector (int n, FixedPoint val) : MArray<FixedPoint> (n, val) { }
+ FixedColumnVector (int n, FixedPoint val)
+ : MArray<FixedPoint> (dim_vector (n,1), val) { }
FixedColumnVector (const FixedColumnVector& a) : MArray<FixedPoint> (a) { }
@@ -140,7 +142,8 @@
FixedPoint min (void) const;
FixedPoint max (void) const;
- friend FixedColumnVector operator * (const FixedMatrix& a, const FixedColumnVector& b);
+ friend FixedColumnVector operator * (const FixedMatrix& a,
+ const FixedColumnVector& b);
friend FixedColumnVector real (const FixedColumnVector &x);
friend FixedColumnVector imag (const FixedColumnVector &x);
@@ -174,15 +177,15 @@
// i/o
- friend std::ostream& operator << (std::ostream& os, const FixedColumnVector& a);
- friend std::istream& operator >> (std::istream& is, FixedColumnVector& a);
+ friend std::ostream& operator << (std::ostream& os,
+ const FixedColumnVector& a);
+ friend std::istream& operator >> (std::istream& is,
+ FixedColumnVector& a);
-private:
-
- FixedColumnVector (FixedPoint *d, int l) : MArray<FixedPoint> (d, l) { }
};
-FixedColumnVector operator * (const FixedMatrix& a, const FixedColumnVector& b);
+FixedColumnVector operator * (const FixedMatrix& a,
+ const FixedColumnVector& b);
FixedColumnVector real (const FixedColumnVector &x);
FixedColumnVector imag (const FixedColumnVector &x);
@@ -206,35 +209,35 @@
FixedColumnVector floor (const FixedColumnVector &x);
FixedColumnVector ceil (const FixedColumnVector &x);
-inline ColumnVector fixedpoint (const FixedColumnVector& x)
- { return x.fixedpoint(); }
-inline ColumnVector sign (const FixedColumnVector& x)
- { return x.sign(); }
-inline ColumnVector signbit (const FixedColumnVector& x)
- { return x.signbit(); }
-inline ColumnVector getdecsize (const FixedColumnVector& x)
- { return x.getdecsize(); }
-inline ColumnVector getintsize (const FixedColumnVector& x)
- { return x.getintsize(); }
-inline ColumnVector getnumber (const FixedColumnVector& x)
- { return x.getnumber(); }
+inline ColumnVector fixedpoint (const FixedColumnVector& x)
+{ return x.fixedpoint(); }
+inline ColumnVector sign (const FixedColumnVector& x)
+{ return x.sign(); }
+inline ColumnVector signbit (const FixedColumnVector& x)
+{ return x.signbit(); }
+inline ColumnVector getdecsize (const FixedColumnVector& x)
+{ return x.getdecsize(); }
+inline ColumnVector getintsize (const FixedColumnVector& x)
+{ return x.getintsize(); }
+inline ColumnVector getnumber (const FixedColumnVector& x)
+{ return x.getnumber(); }
std::ostream& operator << (std::ostream& os, const FixedColumnVector& a);
std::istream& operator >> (std::istream& is, FixedColumnVector& a);
FixedColumnVector elem_pow (const FixedColumnVector &a,
- const FixedColumnVector &b);
+ const FixedColumnVector &b);
FixedColumnVector elem_pow (const FixedColumnVector &a,
- const FixedPoint &b);
+ const FixedPoint &b);
FixedColumnVector elem_pow (const FixedPoint &a,
- const FixedColumnVector &b);
+ const FixedColumnVector &b);
MARRAY_FORWARD_DEFS (MArray, FixedColumnVector, FixedPoint)
#endif
/*
-;;; Local Variables: ***
-;;; mode: C++ ***
-;;; End: ***
+ ;;; Local Variables: ***
+ ;;; mode: C++ ***
+ ;;; End: ***
*/
Index: src/fixedMatrix.h
===================================================================
--- src/fixedMatrix.h (revision 9213)
+++ src/fixedMatrix.h (working copy)
@@ -26,7 +26,7 @@
#if !defined (octave_FixedMatrix_h)
#define octave_FixedMatrix_h 1
-#include <octave/MArray2.h>
+#include <octave/MArray.h>
#include <octave/mx-defs.h>
#include <octave/mx-op-defs.h>
@@ -50,32 +50,34 @@
class
OCTAVE_FIXED_API
-FixedMatrix : public MArray2<FixedPoint>
+FixedMatrix : public MArray<FixedPoint>
{
public:
- FixedMatrix (void) : MArray2<FixedPoint> () { }
+ FixedMatrix (void) : MArray<FixedPoint> () { }
- FixedMatrix (const dim_vector& dv) : MArray2<FixedPoint> (dv) { }
+ FixedMatrix (const dim_vector& dv) : MArray<FixedPoint> (dv) { }
- FixedMatrix (int r, int c) : MArray2<FixedPoint> (r, c) { }
+ FixedMatrix (int r, int c)
+ : MArray<FixedPoint> (dim_vector(r, c)) { }
- FixedMatrix (int r, int c, const FixedPoint val) : MArray2<FixedPoint> (r, c, val) { }
+ FixedMatrix (int r, int c, const FixedPoint val)
+ : MArray<FixedPoint> (dim_vector(r, c), val) { }
- FixedMatrix (const MArray2<int> &is, const MArray2<int> &ds);
+ FixedMatrix (const MArray<int> &is, const MArray<int> &ds);
FixedMatrix (const Matrix &is, const Matrix &ds);
FixedMatrix (unsigned int is, unsigned int ds, const FixedMatrix& a);
- FixedMatrix (const MArray2<int> &is, const MArray2<int> &ds,
+ FixedMatrix (const MArray<int> &is, const MArray<int> &ds,
const FixedMatrix& a);
FixedMatrix (const Matrix &is, const Matrix &ds, const FixedMatrix& a);
FixedMatrix (unsigned int is, unsigned int ds, const Matrix& a);
- FixedMatrix (const MArray2<int> &is, const MArray2<int> &ds,
+ FixedMatrix (const MArray<int> &is, const MArray<int> &ds,
const Matrix& a);
FixedMatrix (const Matrix &is, const Matrix &ds, const Matrix& a);
@@ -83,19 +85,19 @@
FixedMatrix (unsigned int is, unsigned int ds, const Matrix& a,
const Matrix& b);
- FixedMatrix (const MArray2<int> &is, const MArray2<int> &ds,
+ FixedMatrix (const MArray<int> &is, const MArray<int> &ds,
const Matrix& a, const Matrix& b);
FixedMatrix (const Matrix &is, const Matrix &ds, const Matrix& a,
const Matrix& b);
- FixedMatrix (const MArray2<int> &a);
+ FixedMatrix (const MArray<int> &a);
FixedMatrix (const Matrix &a);
- FixedMatrix (const FixedMatrix& a) : MArray2<FixedPoint> (a) { }
- FixedMatrix (const MArray2<FixedPoint>& a) : MArray2<FixedPoint> (a) { }
- FixedMatrix (const Array2<FixedPoint> &a) : MArray2<FixedPoint> (a) { }
+ FixedMatrix (const FixedMatrix& a) : MArray<FixedPoint> (a) { }
+ FixedMatrix (const MArray<FixedPoint>& a) : MArray<FixedPoint> (a) { }
+ FixedMatrix (const Array<FixedPoint> &a) : MArray<FixedPoint> (a) { }
explicit FixedMatrix (const FixedRowVector& rv);
@@ -120,7 +122,7 @@
FixedMatrix& operator = (const FixedMatrix& a)
{
- MArray2<FixedPoint>::operator = (a);
+ MArray<FixedPoint>::operator = (a);
return *this;
}
@@ -151,7 +153,7 @@
FixedMatrix stack (const FixedColumnVector& a) const;
FixedMatrix transpose (void) const
- { return MArray2<FixedPoint>::transpose (); }
+ { return MArray<FixedPoint>::transpose (); }
// resize is the destructive equivalent for this one
@@ -246,9 +248,6 @@
static FixedPoint resize_fill_value (void) { return FixedPoint(); }
-private:
-
- FixedMatrix (FixedPoint *d, int r, int c) : MArray2<FixedPoint> (d, r, c) { }
};
OCTAVE_FIXED_API FixedMatrix operator * (const FixedColumnVector& a, const FixedRowVector& b);
@@ -314,7 +313,7 @@
MM_CMP_OP_DECLS (FixedMatrix, FixedMatrix, )
MM_BOOL_OP_DECLS (FixedMatrix, FixedMatrix, )
-MARRAY_FORWARD_DEFS (MArray2, FixedMatrix, FixedPoint)
+MARRAY_FORWARD_DEFS (MArray, FixedMatrix, FixedPoint)
#endif
Index: src/fixedCMatrix.h
===================================================================
--- src/fixedCMatrix.h (revision 9213)
+++ src/fixedCMatrix.h (working copy)
@@ -26,7 +26,7 @@
#if !defined (octave_FixedCMatrix_h)
#define octave_FixedCMatrix_h 1
-#include <octave/MArray2.h>
+#include <octave/MArray.h>
#include <octave/mx-defs.h>
#include <octave/mx-op-defs.h>
@@ -51,20 +51,21 @@
class
OCTAVE_FIXED_API
-FixedComplexMatrix : public MArray2<FixedPointComplex>
+FixedComplexMatrix : public MArray<FixedPointComplex>
{
public:
- FixedComplexMatrix (void) : MArray2<FixedPointComplex> () { }
+ FixedComplexMatrix (void) : MArray<FixedPointComplex> () { }
- FixedComplexMatrix (const dim_vector& dv) : MArray2<FixedPointComplex> (dv) { }
+ FixedComplexMatrix (const dim_vector& dv) : MArray<FixedPointComplex> (dv) { }
- FixedComplexMatrix (int r, int c) : MArray2<FixedPointComplex> (r, c) { }
+ FixedComplexMatrix (int r, int c)
+ : MArray<FixedPointComplex> (dim_vector (r, c)) { }
- FixedComplexMatrix (int r, int c, const FixedPointComplex val) :
- MArray2<FixedPointComplex> (r, c, val) { }
+ FixedComplexMatrix (int r, int c, const FixedPointComplex val)
+ : MArray<FixedPointComplex> (dim_vector (r, c), val) { }
- FixedComplexMatrix (const MArray2<int> &is, const MArray2<int> &ds);
+ FixedComplexMatrix (const MArray<int> &is, const MArray<int> &ds);
FixedComplexMatrix (const Matrix &is, const Matrix &ds);
@@ -75,7 +76,7 @@
FixedComplexMatrix (Complex is, Complex ds, const FixedComplexMatrix& a);
- FixedComplexMatrix (const MArray2<int> &is, const MArray2<int> &ds,
+ FixedComplexMatrix (const MArray<int> &is, const MArray<int> &ds,
const FixedComplexMatrix& a);
FixedComplexMatrix (const Matrix &is, const Matrix &ds,
@@ -88,7 +89,7 @@
FixedComplexMatrix (Complex is, Complex ds, const FixedMatrix& a);
- FixedComplexMatrix (const MArray2<int> &is, const MArray2<int> &ds,
+ FixedComplexMatrix (const MArray<int> &is, const MArray<int> &ds,
const FixedMatrix& a);
FixedComplexMatrix (const Matrix &is, const Matrix &ds,
@@ -102,7 +103,7 @@
FixedComplexMatrix (Complex is, Complex ds, const ComplexMatrix& a);
- FixedComplexMatrix (const MArray2<int> &is, const MArray2<int> & ds,
+ FixedComplexMatrix (const MArray<int> &is, const MArray<int> & ds,
const ComplexMatrix& a);
FixedComplexMatrix (const Matrix &is, const Matrix & ds,
@@ -115,7 +116,7 @@
FixedComplexMatrix (Complex is, Complex ds, const Matrix& a);
- FixedComplexMatrix (const MArray2<int> &is, const MArray2<int> & ds,
+ FixedComplexMatrix (const MArray<int> &is, const MArray<int> & ds,
const Matrix& a);
FixedComplexMatrix (const Matrix &is, const Matrix & ds, const Matrix& a);
@@ -129,7 +130,7 @@
FixedComplexMatrix (Complex is, Complex ds, const ComplexMatrix &a,
const ComplexMatrix &b);
- FixedComplexMatrix (const MArray2<int> &is, const MArray2<int> &ds,
+ FixedComplexMatrix (const MArray<int> &is, const MArray<int> &ds,
const ComplexMatrix &a, const ComplexMatrix &b);
FixedComplexMatrix (const Matrix &is, const Matrix &ds,
@@ -143,10 +144,10 @@
FixedComplexMatrix (const FixedMatrix& a, const FixedMatrix& b);
FixedComplexMatrix (const FixedComplexMatrix& a) :
- MArray2<FixedPointComplex> (a) { }
+ MArray<FixedPointComplex> (a) { }
- FixedComplexMatrix (const MArray2<FixedPointComplex>& a) :
- MArray2<FixedPointComplex> (a) { }
+ FixedComplexMatrix (const MArray<FixedPointComplex>& a) :
+ MArray<FixedPointComplex> (a) { }
explicit FixedComplexMatrix (const FixedComplexRowVector& rv);
@@ -174,7 +175,7 @@
FixedComplexMatrix& operator = (const FixedComplexMatrix& a)
{
- MArray2<FixedPointComplex>::operator = (a);
+ MArray<FixedPointComplex>::operator = (a);
return *this;
}
@@ -208,7 +209,7 @@
FixedComplexMatrix stack (const FixedComplexColumnVector& a) const;
FixedComplexMatrix hermitian (void) const;
- FixedComplexMatrix transpose (void) const { return MArray2<FixedPointComplex>::transpose (); }
+ FixedComplexMatrix transpose (void) const { return MArray<FixedPointComplex>::transpose (); }
// resize is the destructive equivalent for this one
@@ -312,11 +313,6 @@
static FixedPointComplex resize_fill_value (void)
{ return FixedPointComplex(); }
-
-private:
-
- FixedComplexMatrix (FixedPointComplex *d, int r, int c) :
- MArray2<FixedPointComplex> (d, r, c) { }
};
OCTAVE_FIXED_API FixedComplexMatrix operator * (const FixedComplexColumnVector& a,
@@ -403,7 +399,7 @@
MM_CMP_OP_DECLS (FixedComplexMatrix, FixedComplexMatrix, )
MM_BOOL_OP_DECLS (FixedComplexMatrix, FixedComplexMatrix, )
-MARRAY_FORWARD_DEFS (MArray2, FixedComplexMatrix, FixedPointComplex)
+MARRAY_FORWARD_DEFS (MArray, FixedComplexMatrix, FixedPointComplex)
#endif
Index: src/Array-f.cc
===================================================================
--- src/Array-f.cc (revision 9213)
+++ src/Array-f.cc (working copy)
@@ -58,30 +58,18 @@
INSTANTIATE_MARRAY_FRIENDS (FixedPoint, )
INSTANTIATE_MARRAY_FRIENDS (FixedPointComplex, )
-#include <octave/Array2.h>
-#include <octave/MArray2.h>
-#include <octave/MArray2.cc>
+#include <octave/Array.h>
+#include <octave/Array.cc>
+#include <octave/MArray.h>
+#include <octave/MArray.cc>
-template class Array2<FixedPoint>;
-template class MArray2<FixedPoint>;
-template class Array2<FixedPointComplex>;
-template class MArray2<FixedPointComplex>;
-
-INSTANTIATE_MARRAY2_FRIENDS (FixedPoint, OCTAVE_FIXED_API)
-INSTANTIATE_MARRAY2_FRIENDS (FixedPointComplex, OCTAVE_FIXED_API)
-
-#include <octave/ArrayN.h>
-#include <octave/ArrayN.cc>
-#include <octave/MArrayN.h>
-#include <octave/MArrayN.cc>
-
template class ArrayN<FixedPoint>;
template class MArrayN<FixedPoint>;
template class ArrayN<FixedPointComplex>;
template class MArrayN<FixedPointComplex>;
-INSTANTIATE_MARRAYN_FRIENDS (FixedPoint, )
-INSTANTIATE_MARRAYN_FRIENDS (FixedPointComplex, )
+INSTANTIATE_MARRAY_FRIENDS (FixedPoint, )
+INSTANTIATE_MARRAY_FRIENDS (FixedPointComplex, )
/*
;;; Local Variables: ***
Index: src/fixed-inline.cc
===================================================================
--- src/fixed-inline.cc (revision 9213)
+++ src/fixed-inline.cc (working copy)
@@ -1,24 +1,24 @@
/*
-Copyright (C) 2009 David Bateman
+ Copyright (C) 2009 David Bateman
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2, or (at your option) any
+ later version.
-This program is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
-You should have received a copy of the GNU General Public License
-along with this program; see the file COPYING. If not, see
-<http://www.gnu.org/licenses/>.
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING. If not, see
+ <http://www.gnu.org/licenses/>.
-In addition to the terms of the GPL, you are permitted to link
-this program with any Open Source program, as defined by the
-Open Source Initiative (www.opensource.org)
+ In addition to the terms of the GPL, you are permitted to link
+ this program with any Open Source program, as defined by the
+ Open Source Initiative (www.opensource.org)
*/
@@ -36,7 +36,7 @@
#include <octave/mx-inlines.cc>
-inline FixedPoint
+inline FixedPoint
mx_inline_sumsq (const FixedPointComplex* v, octave_idx_type n)
{
FixedPoint ac = FixedPoint ();
@@ -46,48 +46,48 @@
}
inline void
-mx_inline_sumsq (const FixedPointComplex* v, FixedPoint *r,
- octave_idx_type m, octave_idx_type n)
+mx_inline_sumsq (const FixedPointComplex* v, FixedPoint *r,
+ octave_idx_type m, octave_idx_type n)
{
for (octave_idx_type i = 0; i < m; i++)
r[i] = FixedPoint ();
for (octave_idx_type j = 0; j < n; j++)
- {
- for (octave_idx_type i = 0; i < m; i++)
- OP_RED_SUMSQC(r[i], v[i]);
- v += m;
- }
+ {
+ for (octave_idx_type i = 0; i < m; i++)
+ OP_RED_SUMSQC(r[i], v[i]);
+ v += m;
+ }
}
inline void
mx_inline_sumsq (const FixedPointComplex *v, FixedPoint *r, octave_idx_type l,
- octave_idx_type n, octave_idx_type u)
+ octave_idx_type n, octave_idx_type u)
{
if (l == 1)
+ {
+ for (octave_idx_type i = 0; i < u; i++)
{
- for (octave_idx_type i = 0; i < u; i++)
- {
- r[i] = mx_inline_sumsq (v, n);
- v += n;
- }
+ r[i] = mx_inline_sumsq (v, n);
+ v += n;
}
+ }
else
+ {
+ for (octave_idx_type i = 0; i < u; i++)
{
- for (octave_idx_type i = 0; i < u; i++)
- {
- mx_inline_sumsq (v, r, l, n);
- v += l*n;
- r += l;
- }
+ mx_inline_sumsq (v, r, l, n);
+ v += l*n;
+ r += l;
}
+ }
}
inline bool xis_true (FixedPoint x) {return x != FixedPoint(); }
inline bool xis_false (FixedPoint x) {return x == FixedPoint(); }
-inline bool xis_true (FixedPointComplex x)
- {return x.real() != FixedPoint() || x.imag() != FixedPoint (); }
-inline bool xis_false (FixedPointComplex x)
- {return x.real() == FixedPoint() && x.imag() == FixedPoint (); }
+inline bool xis_true (FixedPointComplex x)
+{return x.real() != FixedPoint() || x.imag() != FixedPoint (); }
+inline bool xis_false (FixedPointComplex x)
+{return x.real() == FixedPoint() && x.imag() == FixedPoint (); }
#endif
Index: src/fixedRowVector.h
===================================================================
--- src/fixedRowVector.h (revision 9213)
+++ src/fixedRowVector.h (working copy)
@@ -1,25 +1,25 @@
/*
-Copyright (C) 2003 Motorola Inc
-Copyright (C) 2003 David Bateman
+ Copyright (C) 2003 Motorola Inc
+ Copyright (C) 2003 David Bateman
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2, or (at your option) any
+ later version.
-This program is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
-You should have received a copy of the GNU General Public License
-along with this program; see the file COPYING. If not, see
-<http://www.gnu.org/licenses/>.
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING. If not, see
+ <http://www.gnu.org/licenses/>.
-In addition to the terms of the GPL, you are permitted to link
-this program with any Open Source program, as defined by the
-Open Source Initiative (www.opensource.org)
+ In addition to the terms of the GPL, you are permitted to link
+ this program with any Open Source program, as defined by the
+ Open Source Initiative (www.opensource.org)
*/
@@ -43,14 +43,14 @@
typedef FixedPoint (*fp_fp_Mapper)(FixedPoint);
class
-OCTAVE_FIXED_API
+OCTAVE_FIXED_API
FixedRowVector : public MArray<FixedPoint>
{
-public:
+ public:
FixedRowVector (void) : MArray<FixedPoint> () { }
- explicit FixedRowVector (int n) : MArray<FixedPoint> (n) { }
+ explicit FixedRowVector (int n) : MArray<FixedPoint> (dim_vector (1,n)) { }
FixedRowVector (const MArray<int> &is, const MArray<int> &ds);
@@ -58,30 +58,31 @@
FixedRowVector (unsigned int is, unsigned int ds, const FixedRowVector& a);
- FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
- const FixedRowVector& a);
+ FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
+ const FixedRowVector& a);
- FixedRowVector (const RowVector &is, const RowVector &ds,
- const FixedRowVector& a);
+ FixedRowVector (const RowVector &is, const RowVector &ds,
+ const FixedRowVector& a);
FixedRowVector (unsigned int is, unsigned int ds, const RowVector& a);
- FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
- const RowVector& a);
+ FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
+ const RowVector& a);
- FixedRowVector (const RowVector &is, const RowVector &ds,
- const RowVector& a);
+ FixedRowVector (const RowVector &is, const RowVector &ds,
+ const RowVector& a);
- FixedRowVector (unsigned int is, unsigned int ds, const RowVector& a,
- const RowVector& b);
+ FixedRowVector (unsigned int is, unsigned int ds, const RowVector& a,
+ const RowVector& b);
- FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
- const RowVector& a, const RowVector& b);
+ FixedRowVector (const MArray<int> &is, const MArray<int> &ds,
+ const RowVector& a, const RowVector& b);
- FixedRowVector (const RowVector &is, const RowVector &ds,
- const RowVector& a, const RowVector& b);
+ FixedRowVector (const RowVector &is, const RowVector &ds,
+ const RowVector& a, const RowVector& b);
- FixedRowVector (int n, FixedPoint val) : MArray<FixedPoint> (n, val) { }
+ FixedRowVector (int n, FixedPoint val)
+ : MArray<FixedPoint> (dim_vector(1, n), val) { }
FixedRowVector (const FixedRowVector& a) : MArray<FixedPoint> (a) { }
@@ -176,9 +177,6 @@
friend std::ostream& operator << (std::ostream& os, const FixedRowVector& a);
friend std::istream& operator >> (std::istream& is, FixedRowVector& a);
-private:
-
- FixedRowVector (FixedPoint *d, int l) : MArray<FixedPoint> (d, l) { }
};
FixedPoint operator * (const FixedRowVector& a, const FixedColumnVector& b);
@@ -206,35 +204,35 @@
FixedRowVector floor (const FixedRowVector &x);
FixedRowVector ceil (const FixedRowVector &x);
-inline RowVector fixedpoint (const FixedRowVector& x)
- { return x.fixedpoint(); }
-inline RowVector sign (const FixedRowVector& x)
- { return x.sign(); }
+inline RowVector fixedpoint (const FixedRowVector& x)
+{ return x.fixedpoint(); }
+inline RowVector sign (const FixedRowVector& x)
+{ return x.sign(); }
inline RowVector signbit (const FixedRowVector& x)
- { return x.signbit(); }
-inline RowVector getdecsize (const FixedRowVector& x)
- { return x.getdecsize(); }
-inline RowVector getintsize (const FixedRowVector& x)
- { return x.getintsize(); }
-inline RowVector getnumber (const FixedRowVector& x)
- { return x.getnumber(); }
+{ return x.signbit(); }
+inline RowVector getdecsize (const FixedRowVector& x)
+{ return x.getdecsize(); }
+inline RowVector getintsize (const FixedRowVector& x)
+{ return x.getintsize(); }
+inline RowVector getnumber (const FixedRowVector& x)
+{ return x.getnumber(); }
std::ostream& operator << (std::ostream& os, const FixedRowVector& a);
std::istream& operator >> (std::istream& is, FixedRowVector& a);
FixedRowVector elem_pow (const FixedRowVector &a,
- const FixedRowVector &b);
+ const FixedRowVector &b);
FixedRowVector elem_pow (const FixedRowVector &a,
- const FixedPoint &b);
+ const FixedPoint &b);
FixedRowVector elem_pow (const FixedPoint &a,
- const FixedRowVector &b);
+ const FixedRowVector &b);
MARRAY_FORWARD_DEFS (MArray, FixedRowVector, FixedPoint)
#endif
/*
-;;; Local Variables: ***
-;;; mode: C++ ***
-;;; End: ***
+ ;;; Local Variables: ***
+ ;;; mode: C++ ***
+ ;;; End: ***
*/
Index: src/fixedColVector.cc
===================================================================
--- src/fixedColVector.cc (revision 9213)
+++ src/fixedColVector.cc (working copy)
@@ -1,26 +1,26 @@
// Fixed Point ColumnVector manipulations.
/*
-Copyright (C) 2003 Motorola Inc
-Copyright (C) 2003 David Bateman
+ Copyright (C) 2003 Motorola Inc
+ Copyright (C) 2003 David Bateman
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2, or (at your option) any
+ later version.
-This program is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
-You should have received a copy of the GNU General Public License
-along with this program; see the file COPYING. If not, see
-<http://www.gnu.org/licenses/>.
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING. If not, see
+ <http://www.gnu.org/licenses/>.
-In addition to the terms of the GPL, you are permitted to link
-this program with any Open Source program, as defined by the
-Open Source Initiative (www.opensource.org)
+ In addition to the terms of the GPL, you are permitted to link
+ this program with any Open Source program, as defined by the
+ Open Source Initiative (www.opensource.org)
*/
@@ -39,9 +39,9 @@
// Fixed Point Column Vector class
-FixedColumnVector::FixedColumnVector (const MArray<int> &is,
- const MArray<int> &ds)
- : MArray<FixedPoint> (is.length())
+FixedColumnVector::FixedColumnVector (const MArray<int> &is,
+ const MArray<int> &ds)
+ : MArray<FixedPoint> (dim_vector (is.length(), 1))
{
if (length() != ds.length()) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -52,9 +52,9 @@
elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i));
}
-FixedColumnVector::FixedColumnVector (const ColumnVector &is,
- const ColumnVector &ds)
- : MArray<FixedPoint> (is.length())
+FixedColumnVector::FixedColumnVector (const ColumnVector &is,
+ const ColumnVector &ds)
+ : MArray<FixedPoint> (dim_vector (is.length(), 1))
{
if (length() != ds.length()) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -65,9 +65,10 @@
elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i));
}
-FixedColumnVector::FixedColumnVector (const MArray<int> &is,
- const MArray<int> &ds, const FixedColumnVector& a)
- : MArray<FixedPoint> (a.length())
+FixedColumnVector::FixedColumnVector (const MArray<int> &is,
+ const MArray<int> &ds,
+ const FixedColumnVector& a)
+ : MArray<FixedPoint> (dim_vector (a.length(), 1))
{
if ((length() != is.length()) || (length() != ds.length())) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -75,13 +76,14 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ a.elem (i));
}
-FixedColumnVector::FixedColumnVector (const ColumnVector &is,
- const ColumnVector &ds, const FixedColumnVector& a)
- : MArray<FixedPoint> (a.length())
+FixedColumnVector::FixedColumnVector (const ColumnVector &is,
+ const ColumnVector &ds,
+ const FixedColumnVector& a)
+ : MArray<FixedPoint> (dim_vector (a.length(), 1))
{
if ((length() != is.length()) || (length() != ds.length())) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -89,21 +91,22 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ a.elem (i));
}
-FixedColumnVector::FixedColumnVector (unsigned int is, unsigned int ds,
- const FixedColumnVector& a)
- : MArray<FixedPoint> (a.length())
+FixedColumnVector::FixedColumnVector (unsigned int is, unsigned int ds,
+ const FixedColumnVector& a)
+ : MArray<FixedPoint> (dim_vector (a.length(), 1))
{
for (int i = 0; i < length (); i++)
elem (i) = FixedPoint(is, ds, a.elem (i));
}
-FixedColumnVector::FixedColumnVector (const MArray<int> &is,
- const MArray<int> &ds, const ColumnVector& a)
- : MArray<FixedPoint> (a.length())
+FixedColumnVector::FixedColumnVector (const MArray<int> &is,
+ const MArray<int> &ds,
+ const ColumnVector& a)
+ : MArray<FixedPoint> (dim_vector (a.length(), 1))
{
if ((length() != is.length()) || (length() != ds.length())) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -111,13 +114,14 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ a.elem (i));
}
-FixedColumnVector::FixedColumnVector (const ColumnVector &is,
- const ColumnVector &ds, const ColumnVector& a)
- : MArray<FixedPoint> (a.length())
+FixedColumnVector::FixedColumnVector (const ColumnVector &is,
+ const ColumnVector &ds,
+ const ColumnVector& a)
+ : MArray<FixedPoint> (dim_vector (a.length(), 1))
{
if ((length() != is.length()) || (length() != ds.length())) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -125,22 +129,23 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ a.elem (i));
}
-FixedColumnVector::FixedColumnVector (unsigned int is, unsigned int ds,
- const ColumnVector& a)
- : MArray<FixedPoint> (a.length())
+FixedColumnVector::FixedColumnVector (unsigned int is, unsigned int ds,
+ const ColumnVector& a)
+ : MArray<FixedPoint> (dim_vector (a.length(), 1))
{
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint(is, ds, a.elem (i));
+ elem (i) = FixedPoint(is, ds, a.elem (i));
}
-FixedColumnVector::FixedColumnVector (const MArray<int> &is,
- const MArray<int> &ds, const ColumnVector& a,
- const ColumnVector& b)
- : MArray<FixedPoint> (a.length())
+FixedColumnVector::FixedColumnVector (const MArray<int> &is,
+ const MArray<int> &ds,
+ const ColumnVector& a,
+ const ColumnVector& b)
+ : MArray<FixedPoint> (dim_vector (a.length(), 1))
{
if ((length() != b.length()) || (length() != is.length()) ||
(length() != ds.length())) {
@@ -149,15 +154,16 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- (unsigned int)a.elem (i),
- (unsigned int)b.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ (unsigned int)a.elem (i),
+ (unsigned int)b.elem (i));
}
-FixedColumnVector::FixedColumnVector (const ColumnVector &is,
- const ColumnVector &ds, const ColumnVector& a,
- const ColumnVector& b)
- : MArray<FixedPoint> (a.length())
+FixedColumnVector::FixedColumnVector (const ColumnVector &is,
+ const ColumnVector &ds,
+ const ColumnVector& a,
+ const ColumnVector& b)
+ : MArray<FixedPoint> (dim_vector (a.length(), 1))
{
if ((length() != b.length()) || (length() != is.length()) ||
(length() != ds.length())) {
@@ -166,14 +172,16 @@
}
for (int i = 0; i < length (); i++)
- elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
- (unsigned int)a.elem (i),
- (unsigned int)b.elem (i));
+ elem (i) = FixedPoint((unsigned int)is(i), (unsigned int)ds(i),
+ (unsigned int)a.elem (i),
+ (unsigned int)b.elem (i));
}
-FixedColumnVector::FixedColumnVector (unsigned int is, unsigned int ds,
- const ColumnVector& a, const ColumnVector& b)
- : MArray<FixedPoint> (a.length())
+FixedColumnVector::FixedColumnVector (unsigned int is,
+ unsigned int ds,
+ const ColumnVector& a,
+ const ColumnVector& b)
+ : MArray<FixedPoint> (dim_vector (a.length(), 1))
{
if (length() != b.length()) {
(*current_liboctave_error_handler) ("vector size mismatch");
@@ -184,16 +192,16 @@
elem (i) = FixedPoint(is, ds, (int)a.elem (i), (int)b.elem (i));
}
-#define GET_FIXED_PROP(METHOD) \
- ColumnVector \
- FixedColumnVector:: METHOD (void) const \
- { \
- int len = length(); \
- ColumnVector retval(len); \
- for (int i = 0; i < len; i++) \
- retval(i) = (double) elem(i) . METHOD (); \
- return retval; \
- } \
+#define GET_FIXED_PROP(METHOD) \
+ ColumnVector \
+ FixedColumnVector:: METHOD (void) const \
+ { \
+ int len = length(); \
+ ColumnVector retval(len); \
+ for (int i = 0; i < len; i++) \
+ retval(i) = (double) elem(i) . METHOD (); \
+ return retval; \
+ } \
GET_FIXED_PROP(sign);
GET_FIXED_PROP(signbit);
@@ -204,7 +212,7 @@
#undef GET_FIXED_PROP
-FixedColumnVector
+FixedColumnVector
FixedColumnVector::chdecsize (const double n)
{
int len = length();
@@ -216,7 +224,7 @@
return retval;
}
-FixedColumnVector
+FixedColumnVector
FixedColumnVector::chdecsize (const ColumnVector &n)
{
int len = length();
@@ -229,12 +237,12 @@
FixedColumnVector retval(len);
for (int i = 0; i < len; i++)
- retval(i) = FixedPoint(elem(i).getintsize(), (int)n(i), elem(i));
+ retval(i) = FixedPoint(elem(i).getintsize(), (int)n(i), elem(i));
return retval;
}
-FixedColumnVector
+FixedColumnVector
FixedColumnVector::chintsize (const double n)
{
int len = length();
@@ -246,7 +254,7 @@
return retval;
}
-FixedColumnVector
+FixedColumnVector
FixedColumnVector::chintsize (const ColumnVector &n)
{
int len = length();
@@ -259,12 +267,12 @@
FixedColumnVector retval(len);
for (int i = 0; i < len; i++)
- retval(i) = FixedPoint((int)n(i), elem(i).getdecsize(), elem(i));
+ retval(i) = FixedPoint((int)n(i), elem(i).getdecsize(), elem(i));
return retval;
}
-FixedColumnVector
+FixedColumnVector
FixedColumnVector::incdecsize (const double n) {
return chdecsize(n + getdecsize());
}
@@ -278,12 +286,12 @@
return chdecsize(n + getdecsize());
}
-FixedColumnVector
+FixedColumnVector
FixedColumnVector::incdecsize () {
return chdecsize(1 + getdecsize());
}
-FixedColumnVector
+FixedColumnVector
FixedColumnVector::incintsize (const double n) {
return chintsize(n + getintsize());
}
@@ -297,7 +305,7 @@
return chintsize(n + getintsize());
}
-FixedColumnVector
+FixedColumnVector
FixedColumnVector::incintsize () {
return chintsize(1 + getintsize());
}
@@ -311,10 +319,10 @@
if (len != a.length ())
return 0;
- for (int i = 0; i < len; i++)
- if (elem(i) != a.elem(i))
- return false;
- return true;
+ for (int i = 0; i < len; i++)
+ if (elem(i) != a.elem(i))
+ return false;
+ return true;
}
bool
@@ -329,18 +337,18 @@
int a_len = a.length ();
if (r < 0 || r + a_len > length ())
- {
- (*current_liboctave_error_handler) ("range error for insert");
- return *this;
- }
+ {
+ (*current_liboctave_error_handler) ("range error for insert");
+ return *this;
+ }
if (a_len > 0)
- {
- make_unique ();
+ {
+ make_unique ();
- for (int i = 0; i < a_len; i++)
- xelem (r+i) = a.elem (i);
- }
+ for (int i = 0; i < a_len; i++)
+ xelem (r+i) = a.elem (i);
+ }
return *this;
}
@@ -351,12 +359,12 @@
int len = length ();
if (len > 0)
- {
- make_unique ();
+ {
+ make_unique ();
- for (int i = 0; i < len; i++)
- xelem (i) = val;
- }
+ for (int i = 0; i < len; i++)
+ xelem (i) = val;
+ }
return *this;
}
@@ -367,20 +375,20 @@
int len = length ();
if (r1 < 0 || r2 < 0 || r1 >= len || r2 >= len)
- {
- (*current_liboctave_error_handler) ("range error for fill");
- return *this;
- }
+ {
+ (*current_liboctave_error_handler) ("range error for fill");
+ return *this;
+ }
if (r1 > r2) { int tmp = r1; r1 = r2; r2 = tmp; }
if (r2 >= r1)
- {
- make_unique ();
+ {
+ make_unique ();
- for (int i = r1; i <= r2; i++)
- xelem (i) = val;
- }
+ for (int i = r1; i <= r2; i++)
+ xelem (i) = val;
+ }
return *this;
}
@@ -445,13 +453,13 @@
if (nc != a_len)
gripe_nonconformant ("operator *", nr, nc, a_len, 1);
else
- {
- retval.resize (nr, FixedPoint());
- if (nr != 0 && nc != 0)
- for (int i = 0; i < nc; i++)
- for (int j = 0; j < nr; j++)
- retval.elem (j) += a.elem(i) * m.elem(j,i);
- }
+ {
+ retval.resize (dim_vector (nr,1), FixedPoint());
+ if (nr != 0 && nc != 0)
+ for (int i = 0; i < nc; i++)
+ for (int j = 0; j < nr; j++)
+ retval.elem (j) += a.elem(i) * m.elem(j,i);
+ }
return retval;
}
@@ -514,13 +522,13 @@
return res;
}
-#define DO_FIXED_VEC_FUNC(FUNC, MT) \
+#define DO_FIXED_VEC_FUNC(FUNC, MT) \
MT FUNC (const FixedColumnVector& x) \
- { \
- MT retval (x.length()); \
+ { \
+ MT retval (x.length()); \
for (int i = 0; i < x.length(); i++) \
- retval(i) = FUNC ( x (i) ); \
- return retval; \
+ retval(i) = FUNC ( x (i) ); \
+ return retval; \
}
DO_FIXED_VEC_FUNC(real, FixedColumnVector);
@@ -542,33 +550,33 @@
DO_FIXED_VEC_FUNC(floor, FixedColumnVector);
DO_FIXED_VEC_FUNC(ceil, FixedColumnVector);
-FixedColumnVector elem_pow (const FixedColumnVector &a,
- const FixedColumnVector &b)
+FixedColumnVector elem_pow (const FixedColumnVector &a,
+ const FixedColumnVector &b)
{
FixedColumnVector retval;
int a_len = a.length ();
int b_len = b.length ();
if (a_len == 1)
- {
- retval.resize(b_len);
- FixedPoint ad = a(0);
- for (int i = 0; i < b_len; i++)
- retval(i) = pow(ad, b(i));
- }
+ {
+ retval.resize(dim_vector (b_len, 1));
+ FixedPoint ad = a(0);
+ for (int i = 0; i < b_len; i++)
+ retval(i) = pow(ad, b(i));
+ }
else if (b_len == 1)
- {
- retval.resize(a_len);
- FixedPoint bd = b(0);
- for (int i = 0; i < a_len; i++)
- retval(i) = pow(a(i), bd);
- }
+ {
+ retval.resize(dim_vector (a_len, 1));
+ FixedPoint bd = b(0);
+ for (int i = 0; i < a_len; i++)
+ retval(i) = pow(a(i), bd);
+ }
else if (a_len == b_len)
- {
- retval.resize(a_len);
- for (int i = 0; i < a_len; i++)
- retval(i) = pow(a(i), b(i));
- }
+ {
+ retval.resize(dim_vector (a_len, 1));
+ for (int i = 0; i < a_len; i++)
+ retval(i) = pow(a(i), b(i));
+ }
else
gripe_nonconformant ("operator .^", a_len, b_len);
@@ -601,22 +609,22 @@
if (len < 1)
is.clear (std::ios::badbit);
else
+ {
+ FixedPoint tmp;
+ for (int i = 0; i < len; i++)
{
- FixedPoint tmp;
- for (int i = 0; i < len; i++)
- {
- is >> tmp;
- if (is)
- a.elem (i) = tmp;
- else
- break;
- }
+ is >> tmp;
+ if (is)
+ a.elem (i) = tmp;
+ else
+ break;
}
+ }
return is;
}
/*
-;;; Local Variables: ***
-;;; mode: C++ ***
-;;; End: ***
+ ;;; Local Variables: ***
+ ;;; mode: C++ ***
+ ;;; End: ***
*/
Index: src/fixedCNDArray.cc
===================================================================
--- src/fixedCNDArray.cc (revision 9213)
+++ src/fixedCNDArray.cc (working copy)
@@ -1,25 +1,25 @@
/*
-Copyright (C) 2004 Motorola Inc
-Copyright (C) 2004 David Bateman
+ Copyright (C) 2004 Motorola Inc
+ Copyright (C) 2004 David Bateman
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2, or (at your option) any
+ later version.
-This program is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
-You should have received a copy of the GNU General Public License
-along with this program; see the file COPYING. If not, see
-<http://www.gnu.org/licenses/>.
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING. If not, see
+ <http://www.gnu.org/licenses/>.
-In addition to the terms of the GPL, you are permitted to link
-this program with any Open Source program, as defined by the
-Open Source Initiative (www.opensource.org)
+ In addition to the terms of the GPL, you are permitted to link
+ this program with any Open Source program, as defined by the
+ Open Source Initiative (www.opensource.org)
*/
@@ -45,8 +45,8 @@
// Fixed Point Complex Matrix class.
-FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is,
- const MArrayN<int> &ds)
+FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is,
+ const MArrayN<int> &ds)
: MArrayN<FixedPointComplex> (is.dims())
{
if (dims () != ds.dims ()) {
@@ -58,8 +58,8 @@
elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i));
}
-FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
- const NDArray &ds)
+FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
+ const NDArray &ds)
: MArrayN<FixedPointComplex> (is.dims())
{
if (dims () != ds.dims ()) {
@@ -71,8 +71,8 @@
elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i));
}
-FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
- const ComplexNDArray &ds)
+FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
+ const ComplexNDArray &ds)
: MArrayN<FixedPointComplex> (is.dims())
{
if (dims () != ds.dims ()) {
@@ -84,17 +84,17 @@
elem (i) = FixedPointComplex(is(i), ds(i));
}
-FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
- unsigned int ds,
- const FixedComplexNDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
+ unsigned int ds,
+ const FixedComplexNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex(is, ds, a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
- const FixedComplexNDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
+ const FixedComplexNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
for (int i = 0; i < nelem (); i++)
@@ -102,8 +102,8 @@
}
FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is,
- const MArrayN<int> &ds,
- const FixedComplexNDArray& a)
+ const MArrayN<int> &ds,
+ const FixedComplexNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -113,12 +113,12 @@
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
- const NDArray &ds,
- const FixedComplexNDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
+ const NDArray &ds,
+ const FixedComplexNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -128,12 +128,12 @@
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ a.elem (i));
}
FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
- const ComplexNDArray &ds,
- const FixedComplexNDArray& a)
+ const ComplexNDArray &ds,
+ const FixedComplexNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -145,17 +145,17 @@
elem (i) = FixedPointComplex(is(i), ds(i), a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
- unsigned int ds,
- const FixedNDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
+ unsigned int ds,
+ const FixedNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex(is, ds, a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
- const FixedNDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
+ const FixedNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
for (int i = 0; i < nelem (); i++)
@@ -163,8 +163,8 @@
}
FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is,
- const MArrayN<int> &ds,
- const FixedNDArray& a)
+ const MArrayN<int> &ds,
+ const FixedNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -174,12 +174,12 @@
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
- const NDArray &ds,
- const FixedNDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
+ const NDArray &ds,
+ const FixedNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -189,12 +189,12 @@
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ a.elem (i));
}
FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
- const ComplexNDArray &ds,
- const FixedNDArray& a)
+ const ComplexNDArray &ds,
+ const FixedNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -206,26 +206,26 @@
elem (i) = FixedPointComplex(is(i), ds(i), FixedPointComplex(a.elem (i)));
}
-FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
- unsigned int ds,
- const ComplexNDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
+ unsigned int ds,
+ const ComplexNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex(is, ds, a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
- const ComplexNDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
+ const ComplexNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex(is, ds, a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is,
- const MArrayN<int> &ds,
- const ComplexNDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is,
+ const MArrayN<int> &ds,
+ const ComplexNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -235,12 +235,12 @@
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
- const NDArray &ds,
- const ComplexNDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
+ const NDArray &ds,
+ const ComplexNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -250,12 +250,12 @@
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ a.elem (i));
}
FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
- const ComplexNDArray &ds,
- const ComplexNDArray& a)
+ const ComplexNDArray &ds,
+ const ComplexNDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -267,26 +267,26 @@
elem (i) = FixedPointComplex(is(i), ds(i), a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
- unsigned int ds,
- const NDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
+ unsigned int ds,
+ const NDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex(is, ds, a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
- const NDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
+ const NDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex(is, ds, a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is,
- const MArrayN<int> &ds,
- const NDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is,
+ const MArrayN<int> &ds,
+ const NDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -296,12 +296,12 @@
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
- const NDArray &ds,
- const NDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
+ const NDArray &ds,
+ const NDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -311,12 +311,12 @@
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex((unsigned int)is(i), (unsigned int)ds(i),
- a.elem (i));
+ a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
- const ComplexNDArray &ds,
- const NDArray& a)
+FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
+ const ComplexNDArray &ds,
+ const NDArray& a)
: MArrayN<FixedPointComplex> (a.dims())
{
if ((dims() != is.dims()) || (dims() != ds.dims())) {
@@ -328,10 +328,10 @@
elem (i) = FixedPointComplex(is(i), ds(i), a.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
- unsigned int ds,
- const ComplexNDArray& a,
- const ComplexNDArray& b)
+FixedComplexNDArray::FixedComplexNDArray (unsigned int is,
+ unsigned int ds,
+ const ComplexNDArray& a,
+ const ComplexNDArray& b)
: MArrayN<FixedPointComplex> (a.dims())
{
if (dims() != b.dims()) {
@@ -343,9 +343,9 @@
elem (i) = FixedPointComplex(is, ds, a.elem (i), b.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
- const ComplexNDArray& a,
- const ComplexNDArray& b)
+FixedComplexNDArray::FixedComplexNDArray (Complex is, Complex ds,
+ const ComplexNDArray& a,
+ const ComplexNDArray& b)
: MArrayN<FixedPointComplex> (a.dims())
{
if (dims() != b.dims()) {
@@ -357,13 +357,13 @@
elem (i) = FixedPointComplex(is, ds, a.elem (i), b.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is,
- const MArrayN<int> &ds,
- const ComplexNDArray& a,
- const ComplexNDArray& b)
+FixedComplexNDArray::FixedComplexNDArray (const MArrayN<int> &is,
+ const MArrayN<int> &ds,
+ const ComplexNDArray& a,
+ const ComplexNDArray& b)
: MArrayN<FixedPointComplex> (a.dims())
{
- if ((dims() != b.dims()) || (dims() != is.dims())
+ if ((dims() != b.dims()) || (dims() != is.dims())
|| (dims() != ds.dims())) {
(*current_liboctave_error_handler) ("NDArray size mismatch");
return;
@@ -373,30 +373,30 @@
elem (i) = FixedPointComplex(is (i), ds (i), a.elem (i), b.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
- const NDArray &ds,
- const ComplexNDArray& a,
- const ComplexNDArray& b)
+FixedComplexNDArray::FixedComplexNDArray (const NDArray &is,
+ const NDArray &ds,
+ const ComplexNDArray& a,
+ const ComplexNDArray& b)
: MArrayN<FixedPointComplex> (a.dims())
{
- if ((dims() != b.dims()) || (dims() != is.dims())
+ if ((dims() != b.dims()) || (dims() != is.dims())
|| (dims() != ds.dims())) {
(*current_liboctave_error_handler) ("NDArray size mismatch");
return;
}
for (int i = 0; i < nelem (); i++)
- elem (i) = FixedPointComplex((unsigned int)is (i),
- (unsigned int)ds (i),
- a.elem (i), b.elem (i));
+ elem (i) = FixedPointComplex((unsigned int)is (i),
+ (unsigned int)ds (i),
+ a.elem (i), b.elem (i));
}
-FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
- const ComplexNDArray &ds, const ComplexNDArray& a,
- const ComplexNDArray& b)
+FixedComplexNDArray::FixedComplexNDArray (const ComplexNDArray &is,
+ const ComplexNDArray &ds, const ComplexNDArray& a,
+ const ComplexNDArray& b)
: MArrayN<FixedPointComplex> (a.dims())
{
- if ((dims() != b.dims()) || (dims() != is.dims())
+ if ((dims() != b.dims()) || (dims() != is.dims())
|| (dims() != ds.dims())) {
(*current_liboctave_error_handler) ("NDArray size mismatch");
return;
@@ -414,28 +414,28 @@
}
FixedComplexNDArray::FixedComplexNDArray (const FixedNDArray& a,
- const FixedNDArray& b)
+ const FixedNDArray& b)
: MArrayN<FixedPointComplex> (a.dims (), FixedPointComplex())
{
if (dims() != b.dims()) {
(*current_liboctave_error_handler) ("NDArray size mismatch");
return;
}
-
+
for (int i = 0; i < nelem (); i++)
elem (i) = FixedPointComplex(a.elem (i), b.elem (i));
}
-#define GET_FIXED_PROP(METHOD) \
- ComplexNDArray \
- FixedComplexNDArray:: METHOD (void) const \
- { \
- int nel = nelem (); \
- ComplexNDArray retval(dims()); \
- for (int i = 0; i < nel; i++) \
- retval(i) = elem(i) . METHOD (); \
- return retval; \
- } \
+#define GET_FIXED_PROP(METHOD) \
+ ComplexNDArray \
+ FixedComplexNDArray:: METHOD (void) const \
+ { \
+ int nel = nelem (); \
+ ComplexNDArray retval(dims()); \
+ for (int i = 0; i < nel; i++) \
+ retval(i) = elem(i) . METHOD (); \
+ return retval; \
+ } \
GET_FIXED_PROP(sign);
GET_FIXED_PROP(getdecsize);
@@ -445,7 +445,7 @@
#undef GET_FIXED_PROP
-FixedComplexNDArray
+FixedComplexNDArray
FixedComplexNDArray::chdecsize (const Complex n)
{
int nel = nelem();
@@ -457,7 +457,7 @@
return retval;
}
-FixedComplexNDArray
+FixedComplexNDArray
FixedComplexNDArray::chdecsize (const ComplexNDArray &n)
{
int nel = nelem();
@@ -475,7 +475,7 @@
return retval;
}
-FixedComplexNDArray
+FixedComplexNDArray
FixedComplexNDArray::chintsize (const Complex n)
{
int nel = nelem();
@@ -487,7 +487,7 @@
return retval;
}
-FixedComplexNDArray
+FixedComplexNDArray
FixedComplexNDArray::chintsize (const ComplexNDArray &n)
{
int nel = nelem();
@@ -500,12 +500,12 @@
FixedComplexNDArray retval(dims());
for (int i = 0; i < nel; i++)
- retval(i) = FixedPointComplex(n(i), elem(i).getdecsize(), elem(i));
+ retval(i) = FixedPointComplex(n(i), elem(i).getdecsize(), elem(i));
return retval;
}
-FixedComplexNDArray
+FixedComplexNDArray
FixedComplexNDArray::incdecsize (const Complex n) {
return chdecsize(n + getdecsize());
}
@@ -519,12 +519,12 @@
return chdecsize(n + getdecsize());
}
-FixedComplexNDArray
+FixedComplexNDArray
FixedComplexNDArray::incdecsize () {
return chdecsize(Complex(1,1) + getdecsize());
}
-FixedComplexNDArray
+FixedComplexNDArray
FixedComplexNDArray::incintsize (const Complex n) {
return chintsize(n + getintsize());
}
@@ -538,7 +538,7 @@
return chintsize(n + getintsize());
}
-FixedComplexNDArray
+FixedComplexNDArray
FixedComplexNDArray::incintsize () {
return chintsize(Complex(1,1) + getintsize());
}
@@ -546,7 +546,7 @@
bool
FixedComplexNDArray::operator == (const FixedComplexNDArray& a) const
{
- if (dims() != a.dims())
+ if (dims() != a.dims())
return false;
for (int i = 0; i < nelem(); i++)
@@ -569,7 +569,7 @@
for (int i = 0; i < nel; i++)
b.elem (i) = ! elem (i) ;
-
+
return b;
}
@@ -628,13 +628,13 @@
return retval;
}
-#define DO_FIXED_MAT_FUNC(FUNC, MT) \
+#define DO_FIXED_MAT_FUNC(FUNC, MT) \
MT FUNC (const FixedComplexNDArray& x) \
- { \
- MT retval (x.dims()); \
- for (int i = 0; i < x.nelem(); i++) \
- retval(i) = FUNC ( x (i) ); \
- return retval; \
+ { \
+ MT retval (x.dims()); \
+ for (int i = 0; i < x.nelem(); i++) \
+ retval(i) = FUNC ( x (i) ); \
+ return retval; \
}
DO_FIXED_MAT_FUNC(real, FixedNDArray);
@@ -671,8 +671,8 @@
return retval;
}
-FixedComplexNDArray elem_pow (const FixedComplexNDArray &a,
- const FixedComplexNDArray &b)
+FixedComplexNDArray elem_pow (const FixedComplexNDArray &a,
+ const FixedComplexNDArray &b)
{
FixedComplexNDArray retval;
dim_vector a_dv = a.dims ();
@@ -681,25 +681,25 @@
int b_nel = b.numel ();
if (a_nel == 1)
- {
- retval.resize(b_dv);
- FixedPointComplex ad = a(0);
- for (int i = 0; i < b_nel; i++)
- retval(i) = pow(ad, b(i));
- }
+ {
+ retval.resize(b_dv);
+ FixedPointComplex ad = a(0);
+ for (int i = 0; i < b_nel; i++)
+ retval(i) = pow(ad, b(i));
+ }
else if (b_nel == 1)
- {
- retval.resize(a_dv);
- FixedPointComplex bd = b(0);
- for (int i = 0; i < a_nel; i++)
- retval(i) = pow(a(i), bd);
- }
+ {
+ retval.resize(a_dv);
+ FixedPointComplex bd = b(0);
+ for (int i = 0; i < a_nel; i++)
+ retval(i) = pow(a(i), bd);
+ }
else if (a_dv == b_dv)
- {
- retval.resize(a_dv);
- for (int i = 0; i < a_nel; i++)
- retval(i) = pow(a(i), b(i));
- }
+ {
+ retval.resize(a_dv);
+ for (int i = 0; i < a_nel; i++)
+ retval(i) = pow(a(i), b(i));
+ }
else
gripe_nonconformant ("operator .^", a_dv, b_dv);
@@ -731,7 +731,7 @@
if (dv.numel () == 0 || dim > dv.length () || dim < 0)
return FixedComplexNDArray ();
-
+
dr(dim) = 1;
FixedComplexNDArray result (dr);
@@ -743,43 +743,43 @@
x_stride *= dv(i);
for (octave_idx_type i = 0; i < dr.numel (); i++)
+ {
+ octave_idx_type x_offset;
+ if (x_stride == 1)
+ x_offset = i * x_len;
+ else
{
- octave_idx_type x_offset;
- if (x_stride == 1)
- x_offset = i * x_len;
- else
- {
- octave_idx_type x_offset2 = 0;
- x_offset = i;
- while (x_offset >= x_stride)
- {
- x_offset -= x_stride;
- x_offset2++;
- }
- x_offset += x_offset2 * x_stride * x_len;
- }
+ octave_idx_type x_offset2 = 0;
+ x_offset = i;
+ while (x_offset >= x_stride)
+ {
+ x_offset -= x_stride;
+ x_offset2++;
+ }
+ x_offset += x_offset2 * x_stride * x_len;
+ }
- octave_idx_type idx_j = 0;
- FixedPointComplex tmp_max = elem (x_offset);
- FixedPoint abs_max = ::abs (tmp_max);
+ octave_idx_type idx_j = 0;
+ FixedPointComplex tmp_max = elem (x_offset);
+ FixedPoint abs_max = ::abs (tmp_max);
- for (octave_idx_type j = 1; j < x_len; j++)
- {
- FixedPointComplex tmp = elem (j * x_stride + x_offset);
- FixedPoint abs_tmp = ::abs (tmp);
+ for (octave_idx_type j = 1; j < x_len; j++)
+ {
+ FixedPointComplex tmp = elem (j * x_stride + x_offset);
+ FixedPoint abs_tmp = ::abs (tmp);
- if (abs_tmp > abs_max)
- {
- idx_j = j;
- tmp_max = tmp;
- abs_max = abs_tmp;
- }
- }
-
- result.elem (i) = tmp_max;
- idx_arg.elem (i) = idx_j;
+ if (abs_tmp > abs_max)
+ {
+ idx_j = j;
+ tmp_max = tmp;
+ abs_max = abs_tmp;
+ }
}
+ result.elem (i) = tmp_max;
+ idx_arg.elem (i) = idx_j;
+ }
+
return result;
}
@@ -798,7 +798,7 @@
if (dv.numel () == 0 || dim > dv.length () || dim < 0)
return FixedComplexNDArray ();
-
+
dr(dim) = 1;
FixedComplexNDArray result (dr);
@@ -810,43 +810,43 @@
x_stride *= dv(i);
for (octave_idx_type i = 0; i < dr.numel (); i++)
+ {
+ octave_idx_type x_offset;
+ if (x_stride == 1)
+ x_offset = i * x_len;
+ else
{
- octave_idx_type x_offset;
- if (x_stride == 1)
- x_offset = i * x_len;
- else
- {
- octave_idx_type x_offset2 = 0;
- x_offset = i;
- while (x_offset >= x_stride)
- {
- x_offset -= x_stride;
- x_offset2++;
- }
- x_offset += x_offset2 * x_stride * x_len;
- }
+ octave_idx_type x_offset2 = 0;
+ x_offset = i;
+ while (x_offset >= x_stride)
+ {
+ x_offset -= x_stride;
+ x_offset2++;
+ }
+ x_offset += x_offset2 * x_stride * x_len;
+ }
- octave_idx_type idx_j = 0;
- FixedPointComplex tmp_min = elem (x_offset);
- FixedPoint abs_min = ::abs (tmp_min);
+ octave_idx_type idx_j = 0;
+ FixedPointComplex tmp_min = elem (x_offset);
+ FixedPoint abs_min = ::abs (tmp_min);
- for (octave_idx_type j = 1; j < x_len; j++)
- {
- FixedPointComplex tmp = elem (j * x_stride + x_offset);
- FixedPoint abs_tmp = ::abs (tmp);
+ for (octave_idx_type j = 1; j < x_len; j++)
+ {
+ FixedPointComplex tmp = elem (j * x_stride + x_offset);
+ FixedPoint abs_tmp = ::abs (tmp);
- if (abs_tmp < abs_min)
- {
- idx_j = j;
- tmp_min = tmp;
- abs_min = abs_tmp;
- }
- }
-
- result.elem (i) = tmp_min;
- idx_arg.elem (i) = idx_j;
+ if (abs_tmp < abs_min)
+ {
+ idx_j = j;
+ tmp_min = tmp;
+ abs_min = abs_tmp;
+ }
}
+ result.elem (i) = tmp_min;
+ idx_arg.elem (i) = idx_j;
+ }
+
return result;
}
@@ -858,47 +858,47 @@
octave_idx_type nd = ndims ();
switch (nd)
- {
- case 1:
- retval = FixedComplexMatrix (Array2<FixedPointComplex>
- (*this, dimensions(0), 1));
- break;
+ {
+ case 1:
+ retval = FixedComplexMatrix (Array2<FixedPointComplex>
+ (*this, dimensions(0), 1));
+ break;
- case 2:
- retval = FixedComplexMatrix (Array2<FixedPointComplex>
- (*this, dimensions(0), dimensions(1)));
- break;
+ case 2:
+ retval = FixedComplexMatrix (Array2<FixedPointComplex>
+ (*this, dimensions(0), dimensions(1)));
+ break;
- default:
- (*current_liboctave_error_handler)
- ("invalid conversion of FixedComplexNDArray to FixedComplexMatrix");
- break;
- }
+ default:
+ (*current_liboctave_error_handler)
+ ("invalid conversion of FixedComplexNDArray to FixedComplexMatrix");
+ break;
+ }
return retval;
}
-FixedComplexNDArray
-FixedComplexNDArray ::concat (const FixedComplexNDArray& rb,
- const Array<octave_idx_type>& ra_idx)
+FixedComplexNDArray
+FixedComplexNDArray ::concat (const FixedComplexNDArray& rb,
+ const Array<octave_idx_type>& ra_idx)
{
if (rb.numel () > 0)
insert (rb, ra_idx);
return *this;
}
-FixedComplexNDArray
-FixedComplexNDArray::concat (const FixedNDArray& rb,
- const Array<octave_idx_type>& ra_idx)
+FixedComplexNDArray
+FixedComplexNDArray::concat (const FixedNDArray& rb,
+ const Array<octave_idx_type>& ra_idx)
{
if (rb.numel () > 0)
insert (FixedComplexNDArray (rb), ra_idx);
return *this;
}
-FixedComplexNDArray&
-FixedComplexNDArray::insert (const FixedComplexNDArray& a,
- const Array<octave_idx_type>& ra_idx)
+FixedComplexNDArray&
+FixedComplexNDArray::insert (const FixedComplexNDArray& a,
+ const Array<octave_idx_type>& ra_idx)
{
Array<FixedPointComplex>::insert (a, ra_idx);
return *this;
@@ -906,15 +906,15 @@
void
FixedComplexNDArray::increment_index (Array<octave_idx_type>& ra_idx,
- const dim_vector& dimensions,
- octave_idx_type start_dimension)
+ const dim_vector& dimensions,
+ octave_idx_type start_dimension)
{
::increment_index (ra_idx, dimensions, start_dimension);
}
-octave_idx_type
+octave_idx_type
FixedComplexNDArray::compute_index (Array<octave_idx_type>& ra_idx,
- const dim_vector& dimensions)
+ const dim_vector& dimensions)
{
return ::compute_index (ra_idx, dimensions);
}
@@ -926,9 +926,9 @@
octave_idx_type nel = a.nelem ();
for (octave_idx_type i = 0; i < nel; i++)
- {
- os << " " << a.elem (i);
- }
+ {
+ os << " " << a.elem (i);
+ }
os << "\n";
return os;
}
@@ -941,25 +941,25 @@
if (nel < 1 )
is.clear (std::ios::badbit);
else
+ {
+ FixedPointComplex tmp;
+ for (octave_idx_type i = 0; i < nel; i++)
{
- FixedPointComplex tmp;
- for (octave_idx_type i = 0; i < nel; i++)
- {
- is >> tmp;
- if (is)
- a.elem (i) = tmp;
- else
- goto done;
- }
+ is >> tmp;
+ if (is)
+ a.elem (i) = tmp;
+ else
+ goto done;
}
+ }
done:
return is;
}
-#define EMPTY_RETURN_CHECK(T) \
- if (nel == 0) \
+#define EMPTY_RETURN_CHECK(T) \
+ if (nel == 0) \
return T (dv);
FixedComplexNDArray
@@ -974,10 +974,10 @@
FixedComplexNDArray result (dv);
for (octave_idx_type i = 0; i < nel; i++)
- {
- OCTAVE_QUIT;
- result (i) = ::abs(m(i)) < cabs ? m(i) : c;
- }
+ {
+ OCTAVE_QUIT;
+ result (i) = ::abs(m(i)) < cabs ? m(i) : c;
+ }
return result;
}
@@ -994,10 +994,10 @@
FixedComplexNDArray result (dv);
for (octave_idx_type i = 0; i < nel; i++)
- {
- OCTAVE_QUIT;
- result (i) = ::abs(m(i)) < cabs ? m(i) : c;
- }
+ {
+ OCTAVE_QUIT;
+ result (i) = ::abs(m(i)) < cabs ? m(i) : c;
+ }
return result;
}
@@ -1009,21 +1009,21 @@
octave_idx_type nel = dv.numel ();
if (dv != b.dims ())
- {
- (*current_liboctave_error_handler)
- ("two-arg min expecting args of same size");
- return FixedComplexNDArray ();
- }
+ {
+ (*current_liboctave_error_handler)
+ ("two-arg min expecting args of same size");
+ return FixedComplexNDArray ();
+ }
EMPTY_RETURN_CHECK (FixedComplexNDArray);
FixedComplexNDArray result (dv);
for (octave_idx_type i = 0; i < nel; i++)
- {
- OCTAVE_QUIT;
- result (i) = ::abs(a(i)) < ::abs(b(i)) ? a(i) : b(i);
- }
+ {
+ OCTAVE_QUIT;
+ result (i) = ::abs(a(i)) < ::abs(b(i)) ? a(i) : b(i);
+ }
return result;
}
@@ -1040,10 +1040,10 @@
FixedComplexNDArray result (dv);
for (octave_idx_type i = 0; i < nel; i++)
- {
- OCTAVE_QUIT;
- result (i) = ::abs(m(i)) > cabs ? m(i) : c;
- }
+ {
+ OCTAVE_QUIT;
+ result (i) = ::abs(m(i)) > cabs ? m(i) : c;
+ }
return result;
}
@@ -1060,10 +1060,10 @@
FixedComplexNDArray result (dv);
for (octave_idx_type i = 0; i < nel; i++)
- {
- OCTAVE_QUIT;
- result (i) = ::abs(m(i)) > cabs ? m(i) : c;
- }
+ {
+ OCTAVE_QUIT;
+ result (i) = ::abs(m(i)) > cabs ? m(i) : c;
+ }
return result;
}
@@ -1075,21 +1075,21 @@
octave_idx_type nel = dv.numel ();
if (dv != b.dims ())
- {
- (*current_liboctave_error_handler)
- ("two-arg max expecting args of same size");
- return FixedComplexNDArray ();
- }
+ {
+ (*current_liboctave_error_handler)
+ ("two-arg max expecting args of same size");
+ return FixedComplexNDArray ();
+ }
EMPTY_RETURN_CHECK (FixedComplexNDArray);
FixedComplexNDArray result (dv);
for (octave_idx_type i = 0; i < nel; i++)
- {
- OCTAVE_QUIT;
- result (i) = ::abs(a(i)) < ::abs(b(i)) ? a(i) : b(i);
- }
+ {
+ OCTAVE_QUIT;
+ result (i) = ::abs(a(i)) < ::abs(b(i)) ? a(i) : b(i);
+ }
return result;
}
@@ -1104,7 +1104,7 @@
NDND_BOOL_OPS(FixedComplexNDArray, FixedComplexNDArray, FixedPointComplex())
/*
-;;; Local Variables: ***
-;;; mode: C++ ***
-;;; End: ***
+ ;;; Local Variables: ***
+ ;;; mode: C++ ***
+ ;;; End: ***
*/
Index: src/fixedMatrix.cc
===================================================================
--- src/fixedMatrix.cc (revision 9213)
+++ src/fixedMatrix.cc (working copy)
@@ -1,25 +1,25 @@
/*
-Copyright (C) 2003 Motorola Inc
-Copyright (C) 2003 David Bateman
+ Copyright (C) 2003 Motorola Inc
+ Copyright (C) 2003 David Bateman
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU General Public License as published by the
-Free Software Foundation; either version 2, or (at your option) any
-later version.
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2, or (at your option) any
+ later version.
-This program is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
-You should have received a copy of the GNU General Public License
-along with this program; see the file COPYING. If not, see
-<http://www.gnu.org/licenses/>.
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING. If not, see
+ <http://www.gnu.org/licenses/>.
-In addition to the terms of the GPL, you are permitted to link
-this program with any Open Source program, as defined by the
-Open Source Initiative (www.opensource.org)
+ In addition to the terms of the GPL, you are permitted to link
+ this program with any Open Source program, as defined by the
+ Open Source Initiative (www.opensource.org)
*/
@@ -44,8 +44,8 @@
// Fixed Point Matrix class.
-FixedMatrix::FixedMatrix (const MArray2<int> &is, const MArray2<int> &ds)
- : MArray2<FixedPoint> (is.rows(), is.cols())
+FixedMatrix::FixedMatrix (const MArray<int> &is, const MArray<int> &ds)
+ : MArray<FixedPoint> (dim_vector (is.rows(), is.cols()))
{
if ((rows() != ds.rows()) || (cols() != ds.cols())) {
(*current_liboctave_error_handler) ("matrix size mismatch");
@@ -59,7 +59,7 @@
FixedMatrix::FixedMatrix (const Matrix &is, const Matrix &ds)
- : MArray2<FixedPoint> (is.rows(), is.cols())
+ : MArray<FixedPoint> (dim_vector (is.rows(), is.cols()))
{
if ((rows() != ds.rows()) || (cols() != ds.cols())) {
(*current_liboctave_error_handler) ("matrix size mismatch");
@@ -71,9 +71,9 @@
elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j));
}
-FixedMatrix::FixedMatrix (const MArray2<int> &is, const MArray2<int> &ds,
- const FixedMatrix& a)
- : MArray2<FixedPoint> (a.rows(), a.cols())
+FixedMatrix::FixedMatrix (const MArray<int> &is, const MArray<int> &ds,
+ const FixedMatrix& a)
+ : MArray<FixedPoint> (dim_vector (a.rows(), a.cols()))
{
if ((rows() != is.rows()) || (cols() != is.cols()) || (rows() != ds.rows())
|| (cols() != ds.cols())) {
@@ -83,13 +83,13 @@
for (int j = 0; j < cols (); j++)
for (int i = 0; i < rows (); i++)
- elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
- a.elem (i, j));
+ elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
+ a.elem (i, j));
}
-FixedMatrix::FixedMatrix (const Matrix &is, const Matrix &ds,
- const FixedMatrix& a)
- : MArray2<FixedPoint> (a.rows(), a.cols())
+FixedMatrix::FixedMatrix (const Matrix &is, const Matrix &ds,
+ const FixedMatrix& a)
+ : MArray<FixedPoint> (dim_vector (a.rows(), a.cols()))
{
if ((rows() != is.rows()) || (cols() != is.cols()) || (rows() != ds.rows())
|| (cols() != ds.cols())) {
@@ -99,22 +99,22 @@
for (int j = 0; j < cols (); j++)
for (int i = 0; i < rows (); i++)
- elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
- a.elem (i, j));
+ elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
+ a.elem (i, j));
}
-FixedMatrix::FixedMatrix (unsigned int is, unsigned int ds,
- const FixedMatrix& a)
- : MArray2<FixedPoint> (a.rows(), a.cols())
+FixedMatrix::FixedMatrix (unsigned int is, unsigned int ds,
+ const FixedMatrix& a)
+ : MArray<FixedPoint> (dim_vector (a.rows(), a.cols()))
{
for (int j = 0; j < cols (); j++)
for (int i = 0; i < rows (); i++)
elem (i, j) = FixedPoint(is, ds, a.elem (i, j));
}
-FixedMatrix::FixedMatrix (const MArray2<int> &is, const MArray2<int> &ds,
- const Matrix& a)
- : MArray2<FixedPoint> (a.rows(), a.cols())
+FixedMatrix::FixedMatrix (const MArray<int> &is, const MArray<int> &ds,
+ const Matrix& a)
+ : MArray<FixedPoint> (dim_vector (a.rows(), a.cols()))
{
if ((rows() != is.rows()) || (cols() != is.cols()) || (rows() != ds.rows())
|| (cols() != ds.cols())) {
@@ -124,13 +124,13 @@
for (int j = 0; j < cols (); j++)
for (int i = 0; i < rows (); i++)
- elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
- a.elem (i, j));
+ elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
+ a.elem (i, j));
}
-FixedMatrix::FixedMatrix (const Matrix &is, const Matrix &ds,
- const Matrix& a)
- : MArray2<FixedPoint> (a.rows(), a.cols())
+FixedMatrix::FixedMatrix (const Matrix &is, const Matrix &ds,
+ const Matrix& a)
+ : MArray<FixedPoint> (dim_vector (a.rows(), a.cols()))
{
if ((rows() != is.rows()) || (cols() != is.cols()) || (rows() != ds.rows())
|| (cols() != ds.cols())) {
@@ -140,21 +140,21 @@
for (int j = 0; j < cols (); j++)
for (int i = 0; i < rows (); i++)
- elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
- a.elem (i, j));
+ elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
+ a.elem (i, j));
}
FixedMatrix::FixedMatrix (unsigned int is, unsigned int ds, const Matrix& a)
- : MArray2<FixedPoint> (a.rows(), a.cols())
+ : MArray<FixedPoint> (dim_vector (a.rows(), a.cols()))
{
for (int j = 0; j < cols (); j++)
for (int i = 0; i < rows (); i++)
elem (i, j) = FixedPoint(is, ds, a.elem (i, j));
}
-FixedMatrix::FixedMatrix (unsigned int is, unsigned int ds, const Matrix& a,
- const Matrix& b)
- : MArray2<FixedPoint> (a.rows(), a.cols())
+FixedMatrix::FixedMatrix (unsigned int is, unsigned int ds, const Matrix& a,
+ const Matrix& b)
+ : MArray<FixedPoint> (dim_vector (a.rows(), a.cols()))
{
if ((rows() != b.rows()) || (cols() != b.cols())) {
(*current_liboctave_error_handler) ("matrix size mismatch");
@@ -163,16 +163,16 @@
for (int j = 0; j < cols (); j++)
for (int i = 0; i < rows (); i++)
- elem (i, j) = FixedPoint(is, ds, (unsigned int)a.elem (i, j),
- (unsigned int)b.elem (i,j));
+ elem (i, j) = FixedPoint(is, ds, (unsigned int)a.elem (i, j),
+ (unsigned int)b.elem (i,j));
}
-FixedMatrix::FixedMatrix (const MArray2<int> &is, const MArray2<int> &ds,
- const Matrix& a, const Matrix& b)
- : MArray2<FixedPoint> (a.rows(), a.cols())
+FixedMatrix::FixedMatrix (const MArray<int> &is, const MArray<int> &ds,
+ const Matrix& a, const Matrix& b)
+ : MArray<FixedPoint> (dim_vector (a.rows(), a.cols()))
{
if ((rows() != b.rows()) || (cols() != b.cols()) || (rows() != is.rows())
- || (cols() != is.cols()) || (rows() != ds.rows())
+ || (cols() != is.cols()) || (rows() != ds.rows())
|| (cols() != ds.cols())) {
(*current_liboctave_error_handler) ("matrix size mismatch");
return;
@@ -180,17 +180,17 @@
for (int j = 0; j < cols (); j++)
for (int i = 0; i < rows (); i++)
- elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
- (unsigned int)a.elem (i, j),
- (unsigned int)b.elem (i,j));
+ elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
+ (unsigned int)a.elem (i, j),
+ (unsigned int)b.elem (i,j));
}
FixedMatrix::FixedMatrix (const Matrix &is, const Matrix &ds, const Matrix& a,
- const Matrix& b)
- : MArray2<FixedPoint> (a.rows(), a.cols())
+ const Matrix& b)
+ : MArray<FixedPoint> (dim_vector (a.rows(), a.cols()))
{
if ((rows() != b.rows()) || (cols() != b.cols()) || (rows() != is.rows())
- || (cols() != is.cols()) || (rows() != ds.rows())
+ || (cols() != is.cols()) || (rows() != ds.rows())
|| (cols() != ds.cols())) {
(*current_liboctave_error_handler) ("matrix size mismatch");
return;
@@ -198,13 +198,13 @@
for (int j = 0; j < cols (); j++)
for (int i = 0; i < rows (); i++)
- elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
- (unsigned int)a.elem (i, j),
- (unsigned int)b.elem (i,j));
+ elem (i, j) = FixedPoint((unsigned int)is(i,j), (unsigned int)ds(i,j),
+ (unsigned int)a.elem (i, j),
+ (unsigned int)b.elem (i,j));
}
-FixedMatrix::FixedMatrix (const MArray2<int> &a)
- : MArray2<FixedPoint> (a.rows(), a.cols())
+FixedMatrix::FixedMatrix (const MArray<int> &a)
+ : MArray<FixedPoint> (dim_vector (a.rows(), a.cols()))
{
for (int j = 0; j < cols (); j++)
@@ -213,7 +213,7 @@
}
FixedMatrix::FixedMatrix (const Matrix &a)
- : MArray2<FixedPoint> (a.rows(), a.cols())
+ : MArray<FixedPoint> (dim_vector (a.rows(), a.cols()))
{
for (int j = 0; j < cols (); j++)
@@ -222,31 +222,31 @@
}
FixedMatrix::FixedMatrix (const FixedRowVector& rv)
- : MArray2<FixedPoint> (1, rv.length (), FixedPoint())
+ : MArray<FixedPoint> (dim_vector (1, rv.length ()), FixedPoint())
{
for (int i = 0; i < rv.length (); i++)
elem (0, i) = rv.elem (i);
}
FixedMatrix::FixedMatrix (const FixedColumnVector& cv)
- : MArray2<FixedPoint> (cv.length (), 1, FixedPoint())
+ : MArray<FixedPoint> (dim_vector (cv.length (), 1), FixedPoint())
{
for (int i = 0; i < cv.length (); i++)
elem (i, 0) = cv.elem (i);
}
-#define GET_FIXED_PROP(METHOD) \
- Matrix \
- FixedMatrix:: METHOD (void) const \
- { \
- int nr = rows(); \
- int nc = cols(); \
- Matrix retval(nr,nc); \
- for (int i = 0; i < nr; i++) \
- for (int j = 0; j < nc; j++) \
- retval(i,j) = (double) elem(i,j) . METHOD (); \
- return retval; \
- } \
+#define GET_FIXED_PROP(METHOD) \
+ Matrix \
+ FixedMatrix:: METHOD (void) const \
+ { \
+ int nr = rows(); \
+ int nc = cols(); \
+ Matrix retval(nr,nc); \
+ for (int i = 0; i < nr; i++) \
+ for (int j = 0; j < nc; j++) \
+ retval(i,j) = (double) elem(i,j) . METHOD (); \
+ return retval; \
+ } \
GET_FIXED_PROP(sign);
GET_FIXED_PROP(signbit);
@@ -257,12 +257,12 @@
#undef GET_FIXED_PROP
-FixedMatrix
+FixedMatrix
FixedMatrix::chdecsize (const double n)
{
int nr = rows();
int nc = cols();
- FixedMatrix retval(nr,nc);
+ FixedMatrix retval(dim_vector (nr,nc));
for (int i = 0; i < nr; i++)
for (int j = 0; j < nc; j++)
@@ -271,7 +271,7 @@
return retval;
}
-FixedMatrix
+FixedMatrix
FixedMatrix::chdecsize (const Matrix &n)
{
int nr = rows();
@@ -282,7 +282,7 @@
return FixedMatrix();
}
- FixedMatrix retval(nr,nc);
+ FixedMatrix retval(dim_vector (nr, nc));
for (int i = 0; i < nr; i++)
for (int j = 0; j < nc; j++)
@@ -291,12 +291,12 @@
return retval;
}
-FixedMatrix
+FixedMatrix
FixedMatrix::chintsize (const double n)
{
int nr = rows();
int nc = cols();
- FixedMatrix retval(nr,nc);
+ FixedMatrix retval(dim_vector (nr, nc));
for (int i = 0; i < nr; i++)
for (int j = 0; j < nc; j++)
@@ -305,7 +305,7 @@
return retval;
}
-FixedMatrix
+FixedMatrix
FixedMatrix::chintsize (const Matrix &n)
{
int nr = rows();
@@ -316,7 +316,7 @@
return FixedMatrix();
}
- FixedMatrix retval(nr,nc);
+ FixedMatrix retval(dim_vector (nr, nc));
for (int i = 0; i < nr; i++)
for (int j = 0; j < nc; j++)
@@ -325,7 +325,7 @@
return retval;
}
-FixedMatrix
+FixedMatrix
FixedMatrix::incdecsize (const double n) {
return chdecsize(n + getdecsize());
}
@@ -339,12 +339,12 @@
return chdecsize(n + getdecsize());
}
-FixedMatrix
+FixedMatrix
FixedMatrix::incdecsize () {
return chdecsize(1 + getdecsize());
}
-FixedMatrix
+FixedMatrix
FixedMatrix::incintsize (const double n) {
return chintsize(n + getintsize());
}
@@ -358,7 +358,7 @@
return chintsize(n + getintsize());
}
-FixedMatrix
+FixedMatrix
FixedMatrix::incintsize () {
return chintsize(1 + getintsize());
}
@@ -369,11 +369,11 @@
if (rows () != a.rows () || cols () != a.cols ())
return false;
- for (int i = 0; i < rows(); i++)
- for (int j = 0; j < cols(); j++)
- if (elem(i,j) != a.elem(i,j))
- return false;
- return true;
+ for (int i = 0; i < rows(); i++)
+ for (int j = 0; j < cols(); j++)
+ if (elem(i,j) != a.elem(i,j))
+ return false;
+ return true;
}
bool
@@ -386,19 +386,19 @@
FixedMatrix::is_symmetric (void) const
{
if (is_square () && rows () > 0)
- {
- for (int i = 0; i < rows (); i++)
- for (int j = i+1; j < cols (); j++)
- if (elem (i, j) != elem (j, i))
- return false;
+ {
+ for (int i = 0; i < rows (); i++)
+ for (int j = i+1; j < cols (); j++)
+ if (elem (i, j) != elem (j, i))
+ return false;
- return true;
- }
+ return true;
+ }
return false;
}
-FixedMatrix
+FixedMatrix
FixedMatrix::concat (const FixedMatrix& rb, const Array<int>& ra_idx)
{
if (rb.numel() > 0)
@@ -406,7 +406,7 @@
return *this;
}
-FixedComplexMatrix
+FixedComplexMatrix
FixedMatrix::concat (const FixedComplexMatrix& rb, const Array<int>& ra_idx)
{
FixedComplexMatrix retval (*this);
@@ -418,7 +418,7 @@
FixedMatrix&
FixedMatrix::insert (const FixedMatrix& a, int r, int c)
{
- Array2<FixedPoint>::insert (a, r, c);
+ Array<FixedPoint>::insert (a, r, c);
return *this;
}
@@ -428,18 +428,18 @@
int a_len = a.length ();
if (r < 0 || r >= rows () || c < 0 || c + a_len > cols ())
- {
- (*current_liboctave_error_handler) ("range error for insert");
- return *this;
- }
+ {
+ (*current_liboctave_error_handler) ("range error for insert");
+ return *this;
+ }
if (a_len > 0)
- {
- make_unique ();
+ {
+ make_unique ();
- for (int i = 0; i < a_len; i++)
- xelem (r, c+i) = a.elem (i);
- }
+ for (int i = 0; i < a_len; i++)
+ xelem (r, c+i) = a.elem (i);
+ }
return *this;
}
@@ -450,18 +450,18 @@
int a_len = a.length ();
if (r < 0 || r + a_len > rows () || c < 0 || c >= cols ())
- {
- (*current_liboctave_error_handler) ("range error for insert");
- return *this;
- }
+ {
+ (*current_liboctave_error_handler) ("range error for insert");
+ return *this;
+ }
if (a_len > 0)
- {
- make_unique ();
+ {
+ make_unique ();
- for (int i = 0; i < a_len; i++)
- xelem (r+i, c) = a.elem (i);
- }
+ for (int i = 0; i < a_len; i++)
+ xelem (r+i, c) = a.elem (i);
+ }
return *this;
}
@@ -473,13 +473,13 @@
int nc = cols ();
if (nr > 0 && nc > 0)
- {
- make_unique ();
+ {
+ make_unique ();
- for (int j = 0; j < nc; j++)
- for (int i = 0; i < nr; i++)
- xelem (i, j) = val;
- }
+ for (int j = 0; j < nc; j++)
+ for (int i = 0; i < nr; i++)
+ xelem (i, j) = val;
+ }
return *this;
}
@@ -492,22 +492,22 @@
if (r1 < 0 || r2 < 0 || c1 < 0 || c2 < 0
|| r1 >= nr || r2 >= nr || c1 >= nc || c2 >= nc)
- {
- (*current_liboctave_error_handler) ("range error for fill");
- return *this;
- }
+ {
+ (*current_liboctave_error_handler) ("range error for fill");
+ return *this;
+ }
if (r1 > r2) { int tmp = r1; r1 = r2; r2 = tmp; }
if (c1 > c2) { int tmp = c1; c1 = c2; c2 = tmp; }
if (r2 >= r1 && c2 >= c1)
- {
- make_unique ();
+ {
+ make_unique ();
- for (int j = c1; j <= c2; j++)
- for (int i = r1; i <= r2; i++)
- xelem (i, j) = val;
- }
+ for (int j = c1; j <= c2; j++)
+ for (int i = r1; i <= r2; i++)
+ xelem (i, j) = val;
+ }
return *this;
}
@@ -518,10 +518,10 @@
int nr = rows ();
int nc = cols ();
if (nr != a.rows ())
- {
- (*current_liboctave_error_handler) ("row dimension mismatch for append");
- return FixedMatrix ();
- }
+ {
+ (*current_liboctave_error_handler) ("row dimension mismatch for append");
+ return FixedMatrix ();
+ }
int nc_insert = nc;
FixedMatrix retval (nr, nc + a.cols ());
@@ -536,10 +536,10 @@
int nr = rows ();
int nc = cols ();
if (nr != 1)
- {
- (*current_liboctave_error_handler) ("row dimension mismatch for append");
- return FixedMatrix ();
- }
+ {
+ (*current_liboctave_error_handler) ("row dimension mismatch for append");
+ return FixedMatrix ();
+ }
int nc_insert = nc;
FixedMatrix retval (nr, nc + a.length ());
@@ -554,10 +554,10 @@
int nr = rows ();
int nc = cols ();
if (nr != a.length ())
- {
- (*current_liboctave_error_handler) ("row dimension mismatch for append");
- return FixedMatrix ();
- }
+ {
+ (*current_liboctave_error_handler) ("row dimension mismatch for append");
+ return FixedMatrix ();
+ }
int nc_insert = nc;
FixedMatrix retval (nr, nc + 1);
@@ -572,11 +572,11 @@
int nr = rows ();
int nc = cols ();
if (nc != a.cols ())
- {
- (*current_liboctave_error_handler)
- ("column dimension mismatch for stack");
- return FixedMatrix ();
- }
+ {
+ (*current_liboctave_error_handler)
+ ("column dimension mismatch for stack");
+ return FixedMatrix ();
+ }
int nr_insert = nr;
FixedMatrix retval (nr + a.rows (), nc);
@@ -591,11 +591,11 @@
int nr = rows ();
int nc = cols ();
if (nc != a.length ())
- {
- (*current_liboctave_error_handler)
- ("column dimension mismatch for stack");
- return FixedMatrix ();
- }
+ {
+ (*current_liboctave_error_handler)
+ ("column dimension mismatch for stack");
+ return FixedMatrix ();
+ }
int nr_insert = nr;
FixedMatrix retval (nr + 1, nc);
@@ -610,11 +610,11 @@
int nr = rows ();
int nc = cols ();
if (nc != 1)
- {
- (*current_liboctave_error_handler)
- ("column dimension mismatch for stack");
- return FixedMatrix ();
- }
+ {
+ (*current_liboctave_error_handler)
+ ("column dimension mismatch for stack");
+ return FixedMatrix ();
+ }
int nr_insert = nr;
FixedMatrix retval (nr + a.length (), nc);
@@ -660,10 +660,10 @@
{
int nc = cols ();
if (i < 0 || i >= rows ())
- {
- (*current_liboctave_error_handler) ("invalid row selection");
- return FixedRowVector ();
- }
+ {
+ (*current_liboctave_error_handler) ("invalid row selection");
+ return FixedRowVector ();
+ }
FixedRowVector retval (nc);
for (int j = 0; j < nc; j++)
@@ -676,10 +676,10 @@
FixedMatrix::row (char *s) const
{
if (! s)
- {
- (*current_liboctave_error_handler) ("invalid row selection");
- return FixedRowVector ();
- }
+ {
+ (*current_liboctave_error_handler) ("invalid row selection");
+ return FixedRowVector ();
+ }
char c = *s;
if (c == 'f' || c == 'F')
@@ -687,10 +687,10 @@
else if (c == 'l' || c == 'L')
return row (rows () - 1);
else
- {
- (*current_liboctave_error_handler) ("invalid row selection");
- return FixedRowVector ();
- }
+ {
+ (*current_liboctave_error_handler) ("invalid row selection");
+ return FixedRowVector ();
+ }
}
FixedColumnVector
@@ -698,10 +698,10 @@
{
int nr = rows ();
if (i < 0 || i >= cols ())
- {
- (*current_liboctave_error_handler) ("invalid column selection");
- return FixedColumnVector ();
- }
+ {
+ (*current_liboctave_error_handler) ("invalid column selection");
+ return FixedColumnVector ();
+ }
FixedColumnVector retval (nr);
for (int j = 0; j < nr; j++)
@@ -714,10 +714,10 @@
FixedMatrix::column (char *s) const
{
if (! s)
- {
- (*current_liboctave_error_handler) ("invalid column selection");
- return FixedColumnVector ();
- }
+ {
+ (*current_liboctave_error_handler) ("invalid column selection");
+ return FixedColumnVector ();
+ }
char c = *s;
if (c == 'f' || c == 'F')
@@ -725,10 +725,10 @@
else if (c == 'l' || c == 'L')
return column (cols () - 1);
else
- {
- (*current_liboctave_error_handler) ("invalid column selection");
- return FixedColumnVector ();
- }
+ {
+ (*current_liboctave_error_handler) ("invalid column selection");
+ return FixedColumnVector ();
+ }
}
// unary operations
@@ -758,15 +758,15 @@
int len = v.length ();
if (len != 0)
- {
- int a_len = a.length ();
+ {
+ int a_len = a.length ();
- retval.resize (len, a_len);
+ retval.resize (dim_vector (len, a_len));
- for (int i = 0; i < len; i++)
- for (int j = 0; j < a_len; j++)
- retval.elem(j,i) = v.elem(i) * a.elem(j);
- }
+ for (int i = 0; i < len; i++)
+ for (int j = 0; j < a_len; j++)
+ retval.elem(j,i) = v.elem(i) * a.elem(j);
+ }
return retval;
}
@@ -867,27 +867,27 @@
FixedColumnVector d;
if (nnr > 0 && nnc > 0)
- {
- int ndiag = (nnr < nnc) ? nnr : nnc;
+ {
+ int ndiag = (nnr < nnc) ? nnr : nnc;
- d.resize (ndiag);
+ d.resize (ndiag);
- if (k > 0)
- {
- for (int i = 0; i < ndiag; i++)
- d.elem (i) = elem (i, i+k);
- }
- else if ( k < 0)
- {
- for (int i = 0; i < ndiag; i++)
- d.elem (i) = elem (i-k, i);
- }
- else
- {
- for (int i = 0; i < ndiag; i++)
- d.elem (i) = elem (i, i);
- }
+ if (k > 0)
+ {
+ for (int i = 0; i < ndiag; i++)
+ d.elem (i) = elem (i, i+k);
}
+ else if ( k < 0)
+ {
+ for (int i = 0; i < ndiag; i++)
+ d.elem (i) = elem (i-k, i);
+ }
+ else
+ {
+ for (int i = 0; i < ndiag; i++)
+ d.elem (i) = elem (i, i);
+ }
+ }
else
std::cerr << "diag: requested diagonal out of range\n";
@@ -910,31 +910,31 @@
int nc = cols ();
if (nr > 0 && nc > 0)
+ {
+ result.resize (nr);
+ index.resize (nr);
+
+ for (int i = 0; i < nr; i++)
{
- result.resize (nr);
- index.resize (nr);
+ int idx_j = 0;
- for (int i = 0; i < nr; i++)
+ FixedPoint tmp_min = elem (i, idx_j);
+
+ for (int j = 1; j < nc; j++)
+ {
+ FixedPoint tmp = elem (i, j);
+ if (tmp < tmp_min)
{
- int idx_j = 0;
+ idx_j = j;
+ tmp_min = tmp;
+ }
+ }
- FixedPoint tmp_min = elem (i, idx_j);
+ result.elem (i) = tmp_min;
+ index.elem (i) = idx_j;
+ }
+ }
- for (int j = 1; j < nc; j++)
- {
- FixedPoint tmp = elem (i, j);
- if (tmp < tmp_min)
- {
- idx_j = j;
- tmp_min = tmp;
- }
- }
-
- result.elem (i) = tmp_min;
- index.elem (i) = idx_j;
- }
- }
-
return result;
}
@@ -954,30 +954,30 @@
int nc = cols ();
if (nr > 0 && nc > 0)
+ {
+ result.resize (nr);
+ index.resize (nr);
+
+ for (int i = 0; i < nr; i++)
{
- result.resize (nr);
- index.resize (nr);
+ int idx_j = 0;
- for (int i = 0; i < nr; i++)
+ FixedPoint tmp_max = elem (i, idx_j);
+
+ for (int j = 1; j < nc; j++)
+ {
+ FixedPoint tmp = elem (i, j);
+ if (tmp > tmp_max)
{
- int idx_j = 0;
+ idx_j = j;
+ tmp_max = tmp;
+ }
+ }
- FixedPoint tmp_max = elem (i, idx_j);
-
- for (int j = 1; j < nc; j++)
- {
- FixedPoint tmp = elem (i, j);
- if (tmp > tmp_max)
- {
- idx_j = j;
- tmp_max = tmp;
- }
- }
-
- result.elem (i) = tmp_max;
- index.elem (i) = idx_j;
- }
+ result.elem (i) = tmp_max;
+ index.elem (i) = idx_j;
}
+ }
return result;
}
@@ -998,30 +998,30 @@
int nc = cols ();
if (nr > 0 && nc > 0)
+ {
+ result.resize (nc);
+ index.resize (nc);
+
+ for (int j = 0; j < nc; j++)
{
- result.resize (nc);
- index.resize (nc);
+ int idx_i = 0;
- for (int j = 0; j < nc; j++)
+ FixedPoint tmp_min = elem (idx_i, j);
+
+ for (int i = 1; i < nr; i++)
+ {
+ FixedPoint tmp = elem (i, j);
+ if (tmp < tmp_min)
{
- int idx_i = 0;
+ idx_i = i;
+ tmp_min = tmp;
+ }
+ }
- FixedPoint tmp_min = elem (idx_i, j);
-
- for (int i = 1; i < nr; i++)
- {
- FixedPoint tmp = elem (i, j);
- if (tmp < tmp_min)
- {
- idx_i = i;
- tmp_min = tmp;
- }
- }
-
- result.elem (j) = tmp_min;
- index.elem (j) = idx_i;
- }
+ result.elem (j) = tmp_min;
+ index.elem (j) = idx_i;
}
+ }
return result;
}
@@ -1042,43 +1042,43 @@
int nc = cols ();
if (nr > 0 && nc > 0)
+ {
+ result.resize (nc);
+ index.resize (nc);
+
+ for (int j = 0; j < nc; j++)
{
- result.resize (nc);
- index.resize (nc);
+ int idx_i = 0;
- for (int j = 0; j < nc; j++)
- {
- int idx_i = 0;
+ FixedPoint tmp_max = elem (idx_i, j);
- FixedPoint tmp_max = elem (idx_i, j);
+ for (int i = 1; i < nr; i++)
+ {
+ FixedPoint tmp = elem (i, j);
- for (int i = 1; i < nr; i++)
- {
- FixedPoint tmp = elem (i, j);
+ if (tmp > tmp_max)
+ {
+ idx_i = i;
+ tmp_max = tmp;
+ }
+ }
- if (tmp > tmp_max)
- {
- idx_i = i;
- tmp_max = tmp;
- }
- }
-
- result.elem (j) = tmp_max;
- index.elem (j) = idx_i;
- }
+ result.elem (j) = tmp_max;
+ index.elem (j) = idx_i;
}
+ }
return result;
}
-#define DO_FIXED_MAT_FUNC(FUNC) \
+#define DO_FIXED_MAT_FUNC(FUNC) \
FixedMatrix FUNC (const FixedMatrix& x) \
- { \
+ { \
FixedMatrix retval ( x.rows(), x.cols()); \
- for (int j = 0; j < x.cols(); j++) \
- for (int i = 0; i < x.rows(); i++) \
- retval(i,j) = FUNC ( x (i,j) ); \
- return retval; \
+ for (int j = 0; j < x.cols(); j++) \
+ for (int i = 0; i < x.rows(); i++) \
+ retval(i,j) = FUNC ( x (i,j) ); \
+ return retval; \
}
DO_FIXED_MAT_FUNC(real);
@@ -1109,28 +1109,28 @@
int b_nc = b.cols ();
if (a_nr == 1 && a_nc == 1)
- {
- retval.resize(b_nr,b_nc);
- FixedPoint ad = a(0,0);
- for (int j = 0; j < b_nc; j++)
- for (int i = 0; i < b_nr; i++)
- retval(i,j) = pow(ad, b(i,j));
- }
+ {
+ retval.resize(b_nr,b_nc);
+ FixedPoint ad = a(0,0);
+ for (int j = 0; j < b_nc; j++)
+ for (int i = 0; i < b_nr; i++)
+ retval(i,j) = pow(ad, b(i,j));
+ }
else if (b_nr == 1 && b_nc == 1)
- {
- retval.resize(a_nr,a_nc);
- FixedPoint bd = b(0,0);
- for (int j = 0; j < a_nc; j++)
- for (int i = 0; i < a_nr; i++)
- retval(i,j) = pow(a(i,j), bd);
- }
+ {
+ retval.resize(a_nr,a_nc);
+ FixedPoint bd = b(0,0);
+ for (int j = 0; j < a_nc; j++)
+ for (int i = 0; i < a_nr; i++)
+ retval(i,j) = pow(a(i,j), bd);
+ }
else if ((a_nr == b_nr) && (a_nc == b_nc))
- {
- retval.resize(a_nr,a_nc);
- for (int j = 0; j < a_nc; j++)
- for (int i = 0; i < a_nr; i++)
- retval(i,j) = pow(a(i,j), b(i,j));
- }
+ {
+ retval.resize(a_nr,a_nc);
+ for (int j = 0; j < a_nc; j++)
+ for (int i = 0; i < a_nr; i++)
+ retval(i,j) = pow(a(i,j), b(i,j));
+ }
else
gripe_nonconformant ("operator .^", a_nr, a_nc, a_nr, a_nc);
@@ -1156,34 +1156,34 @@
if (nr == 0 || nc == 0 || nr != nc)
(*current_liboctave_error_handler)
("for A^x, A must be square and x scalar");
- else if (b == 0)
- {
- retval = a;
- for (int j = 0; j < nc; j++)
- for (int i = 0; i < nr; i++)
- retval(i,j) =
- FixedPoint(a(i,j).getintsize(), a(i,j).getdecsize(), 1, 0);
- }
+ else if (b == 0)
+ {
+ retval = a;
+ for (int j = 0; j < nc; j++)
+ for (int i = 0; i < nr; i++)
+ retval(i,j) =
+ FixedPoint(a(i,j).getintsize(), a(i,j).getdecsize(), 1, 0);
+ }
else
+ {
+ if (b < 0 )
+ (*current_liboctave_error_handler)
+ ("can not treat matrix inversion");
+
+ FixedMatrix atmp (a);
+ retval = atmp;
+ b--;
+ while (b > 0)
{
- if (b < 0 )
- (*current_liboctave_error_handler)
- ("can not treat matrix inversion");
+ if (b & 1)
+ retval = retval * atmp;
- FixedMatrix atmp (a);
- retval = atmp;
- b--;
- while (b > 0)
- {
- if (b & 1)
- retval = retval * atmp;
+ b >>= 1;
- b >>= 1;
-
- if (b > 0)
- atmp = atmp * atmp;
- }
+ if (b > 0)
+ atmp = atmp * atmp;
}
+ }
return retval;
}
@@ -1206,7 +1206,7 @@
FixedMatrix pow (const FixedMatrix &a, const FixedMatrix &b)
{
- if (a.rows() == 0 || a.rows() == 0 || a.rows() != a.rows() ||
+ if (a.rows() == 0 || a.rows() == 0 || a.rows() != a.rows() ||
b.rows() != 1 || b.cols() != 1) {
(*current_liboctave_error_handler)
("for A^x, A must be square and x scalar");
@@ -1222,7 +1222,7 @@
retval.resize(x.rows(),x.cols());
for (int j = 0; j < x.cols(); j++)
for (int i = 0; i < x.rows(); i++)
- retval(i,j) = atan2 ( x(i,j), y(i,j));
+ retval(i,j) = atan2 ( x(i,j), y(i,j));
} else
(*current_liboctave_error_handler) ("matrix size mismatch");
return retval;
@@ -1232,13 +1232,13 @@
operator << (std::ostream& os, const FixedMatrix& a)
{
for (int i = 0; i < a.rows (); i++)
+ {
+ for (int j = 0; j < a.cols (); j++)
{
- for (int j = 0; j < a.cols (); j++)
- {
- os << " " << a.elem(i,j);
- }
- os << "\n";
+ os << " " << a.elem(i,j);
}
+ os << "\n";
+ }
return os;
}
@@ -1251,18 +1251,18 @@
if (nr < 1 || nc < 1)
is.clear (std::ios::badbit);
else
- {
- FixedPoint tmp;
- for (int i = 0; i < nr; i++)
- for (int j = 0; j < nc; j++)
- {
- is >> tmp;
- if (is)
- a.elem (i, j) = tmp;
- else
- goto done;
- }
- }
+ {
+ FixedPoint tmp;
+ for (int i = 0; i < nr; i++)
+ for (int j = 0; j < nc; j++)
+ {
+ is >> tmp;
+ if (is)
+ a.elem (i, j) = tmp;
+ else
+ goto done;
+ }
+ }
done:
@@ -1283,18 +1283,18 @@
if (a_nc != b_nr)
gripe_nonconformant ("operator *", a_nr, a_nc, b_nr, b_nc);
else
+ {
+ retval.resize (a_nr, b_nc, FixedPoint());
+ if (a_nr != 0 && a_nc != 0 && b_nc != 0)
{
- retval.resize (a_nr, b_nc, FixedPoint());
- if (a_nr != 0 && a_nc != 0 && b_nc != 0)
- {
- for (int j = 0; j < b_nr; j++)
- for (int i = 0; i < b_nc; i++) {
- FixedPoint tmp = b.elem(j,i);
- for (int k = 0; k < a_nr; k++)
- retval.elem (k,i) += a.elem(k,j) * tmp;
- }
- }
+ for (int j = 0; j < b_nr; j++)
+ for (int i = 0; i < b_nc; i++) {
+ FixedPoint tmp = b.elem(j,i);
+ for (int k = 0; k < a_nr; k++)
+ retval.elem (k,i) += a.elem(k,j) * tmp;
+ }
}
+ }
return retval;
}
@@ -1302,8 +1302,8 @@
// XXX FIXME XXX -- it would be nice to share code among the min/max
// functions below.
-#define EMPTY_RETURN_CHECK(T) \
- if (nr == 0 || nc == 0) \
+#define EMPTY_RETURN_CHECK(T) \
+ if (nr == 0 || nc == 0) \
return T (nr, nc);
FixedMatrix
@@ -1318,10 +1318,10 @@
for (int j = 0; j < nc; j++)
for (int i = 0; i < nr; i++)
- {
- OCTAVE_QUIT;
- result (i, j) = m(i,j) < d ? m(i,j) : d;
- }
+ {
+ OCTAVE_QUIT;
+ result (i, j) = m(i,j) < d ? m(i,j) : d;
+ }
return result;
}
@@ -1338,10 +1338,10 @@
for (int j = 0; j < nc; j++)
for (int i = 0; i < nr; i++)
- {
- OCTAVE_QUIT;
- result (i, j) = m(i,j) < d ? m(i,j) : d;
- }
+ {
+ OCTAVE_QUIT;
+ result (i, j) = m(i,j) < d ? m(i,j) : d;
+ }
return result;
}
@@ -1353,11 +1353,11 @@
int nc = a.columns ();
if (nr != b.rows () || nc != b.columns ())
- {
- (*current_liboctave_error_handler)
- ("two-arg min expecting args of same size");
- return FixedMatrix ();
- }
+ {
+ (*current_liboctave_error_handler)
+ ("two-arg min expecting args of same size");
+ return FixedMatrix ();
+ }
EMPTY_RETURN_CHECK (FixedMatrix);
@@ -1365,10 +1365,10 @@
for (int j = 0; j < nc; j++)
for (int i = 0; i < nr; i++)
- {
- OCTAVE_QUIT;
- result (i, j) = a(i,j) < b(i,j) ? a(i,j) : b(i,j);
- }
+ {
+ OCTAVE_QUIT;
+ result (i, j) = a(i,j) < b(i,j) ? a(i,j) : b(i,j);
+ }
return result;
}
@@ -1385,10 +1385,10 @@
for (int j = 0; j < nc; j++)
for (int i = 0; i < nr; i++)
- {
- OCTAVE_QUIT;
- result (i, j) = m(i,j) > d ? m(i,j) : d;
- }
+ {
+ OCTAVE_QUIT;
+ result (i, j) = m(i,j) > d ? m(i,j) : d;
+ }
return result;
}
@@ -1405,10 +1405,10 @@
for (int j = 0; j < nc; j++)
for (int i = 0; i < nr; i++)
- {
- OCTAVE_QUIT;
- result (i, j) = m(i,j) > d ? m(i,j) : d;
- }
+ {
+ OCTAVE_QUIT;
+ result (i, j) = m(i,j) > d ? m(i,j) : d;
+ }
return result;
}
@@ -1420,11 +1420,11 @@
int nc = a.columns ();
if (nr != b.rows () || nc != b.columns ())
- {
- (*current_liboctave_error_handler)
- ("two-arg max expecting args of same size");
- return FixedMatrix ();
- }
+ {
+ (*current_liboctave_error_handler)
+ ("two-arg max expecting args of same size");
+ return FixedMatrix ();
+ }
EMPTY_RETURN_CHECK (FixedMatrix);
@@ -1432,25 +1432,25 @@
for (int j = 0; j < nc; j++)
for (int i = 0; i < nr; i++)
- {
- OCTAVE_QUIT;
- result (i, j) = a(i,j) > b(i,j) ? a(i,j) : b(i,j);
- }
+ {
+ OCTAVE_QUIT;
+ result (i, j) = a(i,j) > b(i,j) ? a(i,j) : b(i,j);
+ }
return result;
}
-MS_CMP_OPS(FixedMatrix, , FixedPoint, )
-MS_BOOL_OPS(FixedMatrix, FixedPoint, FixedPoint())
+MS_CMP_OPS(FixedMatrix, FixedPoint)
+MS_BOOL_OPS(FixedMatrix, FixedPoint)
-SM_CMP_OPS(FixedPoint, , FixedMatrix, )
-SM_BOOL_OPS(FixedPoint, FixedMatrix, FixedPoint())
+SM_CMP_OPS(FixedPoint, FixedMatrix)
+SM_BOOL_OPS(FixedPoint, FixedMatrix)
-MM_CMP_OPS(FixedMatrix, , FixedMatrix, )
-MM_BOOL_OPS(FixedMatrix, FixedMatrix, FixedPoint())
+MM_CMP_OPS(FixedMatrix, FixedMatrix)
+MM_BOOL_OPS(FixedMatrix, FixedMatrix)
/*
-;;; Local Variables: ***
-;;; mode: C++ ***
-;;; End: ***
+ ;;; Local Variables: ***
+ ;;; mode: C++ ***
+ ;;; End: ***
*/
Index: src/fixedCNDArray.h
===================================================================
--- src/fixedCNDArray.h (revision 9213)
+++ src/fixedCNDArray.h (working copy)
@@ -26,7 +26,7 @@
#if !defined (octave_FixedCNDArray_h)
#define octave_FixedCNDArray_h 1
-#include <octave/MArrayN.h>
+#include <octave/MArray.h>
#include <octave/dMatrix.h>
#include <octave/dNDArray.h>
@@ -45,19 +45,19 @@
#include "fixedNDArray.h"
class
-FixedComplexNDArray : public MArrayN<FixedPointComplex>
+FixedComplexNDArray : public MArray<FixedPointComplex>
{
public:
- FixedComplexNDArray (void) : MArrayN<FixedPointComplex> () { }
+ FixedComplexNDArray (void) : MArray<FixedPointComplex> () { }
FixedComplexNDArray (const dim_vector& dv)
- : MArrayN<FixedPointComplex> (dv) { }
+ : MArray<FixedPointComplex> (dv) { }
FixedComplexNDArray (const dim_vector& dv, const FixedPointComplex val) :
- MArrayN<FixedPointComplex> (dv, val) { }
+ MArray<FixedPointComplex> (dv, val) { }
- FixedComplexNDArray (const MArrayN<int> &is, const MArrayN<int> &ds);
+ FixedComplexNDArray (const MArray<int> &is, const MArray<int> &ds);
FixedComplexNDArray (const NDArray &is, const NDArray &ds);
@@ -69,7 +69,7 @@
FixedComplexNDArray (Complex is, Complex ds,
const FixedComplexNDArray& a);
- FixedComplexNDArray (const MArrayN<int> &is, const MArrayN<int> &ds,
+ FixedComplexNDArray (const MArray<int> &is, const MArray<int> &ds,
const FixedComplexNDArray& a);
FixedComplexNDArray (const NDArray &is, const NDArray &ds,
@@ -83,7 +83,7 @@
FixedComplexNDArray (Complex is, Complex ds, const FixedNDArray& a);
- FixedComplexNDArray (const MArrayN<int> &is, const MArrayN<int> &ds,
+ FixedComplexNDArray (const MArray<int> &is, const MArray<int> &ds,
const FixedNDArray& a);
FixedComplexNDArray (const NDArray &is, const NDArray &ds,
@@ -97,7 +97,7 @@
FixedComplexNDArray (Complex is, Complex ds, const ComplexNDArray& a);
- FixedComplexNDArray (const MArrayN<int> &is, const MArrayN<int> & ds,
+ FixedComplexNDArray (const MArray<int> &is, const MArray<int> & ds,
const ComplexNDArray& a);
FixedComplexNDArray (const NDArray &is, const NDArray & ds,
@@ -111,7 +111,7 @@
FixedComplexNDArray (Complex is, Complex ds, const NDArray& a);
- FixedComplexNDArray (const MArrayN<int> &is, const MArrayN<int> & ds,
+ FixedComplexNDArray (const MArray<int> &is, const MArray<int> & ds,
const NDArray& a);
FixedComplexNDArray (const NDArray &is, const NDArray & ds,
@@ -126,7 +126,7 @@
FixedComplexNDArray (Complex is, Complex ds, const ComplexNDArray &a,
const ComplexNDArray &b);
- FixedComplexNDArray (const MArrayN<int> &is, const MArrayN<int> &ds,
+ FixedComplexNDArray (const MArray<int> &is, const MArray<int> &ds,
const ComplexNDArray &a, const ComplexNDArray &b);
FixedComplexNDArray (const NDArray &is, const NDArray &ds,
@@ -140,13 +140,13 @@
FixedComplexNDArray (const FixedNDArray& a, const FixedNDArray& b);
FixedComplexNDArray (const FixedComplexNDArray& a)
- : MArrayN<FixedPointComplex> (a) { }
+ : MArray<FixedPointComplex> (a) { }
- FixedComplexNDArray (const MArrayN<FixedPointComplex>& a)
- : MArrayN<FixedPointComplex> (a) { }
+ FixedComplexNDArray (const MArray<FixedPointComplex>& a)
+ : MArray<FixedPointComplex> (a) { }
- FixedComplexNDArray (const ArrayN<FixedPointComplex>& a)
- : MArrayN<FixedPointComplex> (a) { }
+ FixedComplexNDArray (const Array<FixedPointComplex>& a)
+ : MArray<FixedPointComplex> (a) { }
ComplexNDArray sign (void) const;
ComplexNDArray getdecsize (void) const;
@@ -166,7 +166,7 @@
FixedComplexNDArray& operator = (const FixedComplexNDArray& a)
{
- MArrayN<FixedPointComplex>::operator = (a);
+ MArray<FixedPointComplex>::operator = (a);
return *this;
}
@@ -194,16 +194,16 @@
FixedComplexNDArray sumsq (octave_idx_type dim = -1) const;
FixedComplexNDArray max (octave_idx_type dim = 0) const;
- FixedComplexNDArray max (ArrayN<octave_idx_type>& index, octave_idx_type dim = 0) const;
+ FixedComplexNDArray max (Array<octave_idx_type>& index, octave_idx_type dim = 0) const;
FixedComplexNDArray min (octave_idx_type dim = 0) const;
- FixedComplexNDArray min (ArrayN<octave_idx_type>& index, octave_idx_type dim = 0) const;
+ FixedComplexNDArray min (Array<octave_idx_type>& index, octave_idx_type dim = 0) const;
FixedNDArray abs (void) const;
FixedComplexMatrix fixed_complex_matrix_value (void) const;
FixedComplexNDArray squeeze (void) const
- { return ArrayN<FixedPointComplex>::squeeze (); }
+ { return Array<FixedPointComplex>::squeeze (); }
static void increment_index (Array<octave_idx_type>& ra_idx,
const dim_vector& dimensions,
@@ -255,7 +255,7 @@
private:
FixedComplexNDArray (FixedPointComplex *d, const dim_vector& dv)
- : MArrayN<FixedPointComplex> (d, dv) { }
+ : MArray<FixedPointComplex> (d, dv) { }
};
@@ -330,7 +330,7 @@
NDND_CMP_OP_DECLS (FixedComplexNDArray, FixedComplexNDArray, )
NDND_BOOL_OP_DECLS (FixedComplexNDArray, FixedComplexNDArray, )
-MARRAY_FORWARD_DEFS (MArrayN, FixedComplexNDArray, FixedPointComplex)
+MARRAY_FORWARD_DEFS (MArray, FixedComplexNDArray, FixedPointComplex)
#endif
Reply to: