Mercurial > octave-nkf
changeset 7503:8c32f95c2639
convert mapper functions to new format
line wrap: on
line diff
--- a/liboctave/Array.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/Array.h Wed Feb 20 04:22:50 2008 -0500 @@ -32,8 +32,8 @@ #include "dim-vector.h" #include "lo-utils.h" - #include "oct-sort.h" +#include "quit.h" class idx_vector; @@ -549,6 +549,27 @@ Array<T> sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const; Array<T> sort (Array<octave_idx_type> &sidx, octave_idx_type dim = 0, sortmode mode = ASCENDING) const; + + template <class U, class F> + Array<U> + map (F fcn) const + { + octave_idx_type len = length (); + + const T *m = data (); + + Array<U> result (dims ()); + U *p = result.fortran_vec (); + + for (octave_idx_type i = 0; i < len; i++) + { + OCTAVE_QUIT; + + p[i] = fcn (m[i]); + } + + return result; + } }; // NOTE: these functions should be friends of the Array<T> class and
--- a/liboctave/Array2.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/Array2.h Wed Feb 20 04:22:50 2008 -0500 @@ -75,6 +75,13 @@ Array2 (const Array<T>& a, octave_idx_type r, octave_idx_type c) : Array<T> (a, dim_vector (r, c)) { } + template <class U> + Array2 (const Array<U>& a) : Array<T> (a) { } + + template <class U> + Array2 (const Array<U>& a, const dim_vector& dv) + : Array<T> (a, dv) { } + ~Array2 (void) { } Array2<T>& operator = (const Array2<T>& a) @@ -128,6 +135,12 @@ Array<T> tmp = Array<T>::sort (sidx, dim, mode); return Array2<T> (tmp, tmp.rows (), tmp.columns ()); } + + template <class U, class F> + Array2<U> map (F fcn) const + { + return Array<T>::template map<U> (fcn); + } }; #endif
--- a/liboctave/ArrayN.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/ArrayN.h Wed Feb 20 04:22:50 2008 -0500 @@ -148,6 +148,12 @@ Array<T> tmp = Array<T>::sort (sidx, dim, mode); return ArrayN<T> (tmp, tmp.dims ()); } + + template <class U, class F> + ArrayN<U> map (F fcn) const + { + return Array<T>::template map<U> (fcn); + } }; template <class T>
--- a/liboctave/CColVector.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/CColVector.cc Wed Feb 20 04:22:50 2008 -0500 @@ -30,6 +30,7 @@ #include "Array-util.h" #include "f77-fcn.h" +#include "functor.h" #include "lo-error.h" #include "mx-base.h" #include "mx-inlines.cc" @@ -456,39 +457,16 @@ // other operations -ComplexColumnVector -ComplexColumnVector::map (c_c_Mapper f) const +ColumnVector +ComplexColumnVector::map (dmapper fcn) const { - ComplexColumnVector b (*this); - return b.apply (f); + return MArray<Complex>::map<double> (func_ptr (fcn)); } -ColumnVector -ComplexColumnVector::map (d_c_Mapper f) const +ComplexColumnVector +ComplexColumnVector::map (cmapper fcn) const { - const Complex *d = data (); - - octave_idx_type len = length (); - - ColumnVector retval (len); - - double *r = retval.fortran_vec (); - - for (octave_idx_type i = 0; i < len; i++) - r[i] = f (d[i]); - - return retval; -} - -ComplexColumnVector& -ComplexColumnVector::apply (c_c_Mapper f) -{ - Complex *d = fortran_vec (); // Ensures only one reference to my privates! - - for (octave_idx_type i = 0; i < length (); i++) - d[i] = f (d[i]); - - return *this; + return MArray<Complex>::map<Complex> (func_ptr (fcn)); } Complex
--- a/liboctave/CColVector.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/CColVector.h Wed Feb 20 04:22:50 2008 -0500 @@ -114,10 +114,11 @@ // other operations - ComplexColumnVector map (c_c_Mapper f) const; - ColumnVector map (d_c_Mapper f) const; + typedef double (*dmapper) (const Complex&); + typedef Complex (*cmapper) (const Complex&); - ComplexColumnVector& apply (c_c_Mapper f); + ColumnVector map (dmapper fcn) const; + ComplexColumnVector map (cmapper fcn) const; Complex min (void) const; Complex max (void) const;
--- a/liboctave/CMatrix.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/CMatrix.cc Wed Feb 20 04:22:50 2008 -0500 @@ -44,6 +44,7 @@ #include "CmplxSVD.h" #include "CmplxCHOL.h" #include "f77-fcn.h" +#include "functor.h" #include "lo-error.h" #include "lo-ieee.h" #include "lo-mappers.h" @@ -3097,52 +3098,22 @@ // other operations -ComplexMatrix -ComplexMatrix::map (c_c_Mapper f) const -{ - ComplexMatrix b (*this); - return b.apply (f); -} - Matrix -ComplexMatrix::map (d_c_Mapper f) const +ComplexMatrix::map (dmapper fcn) const { - octave_idx_type nr = rows (); - octave_idx_type nc = cols (); - - Matrix retval (nr, nc); - - for (octave_idx_type j = 0; j < nc; j++) - for (octave_idx_type i = 0; i < nr; i++) - retval(i,j) = f (elem(i,j)); - - return retval; + return MArray2<Complex>::map<double> (func_ptr (fcn)); +} + +ComplexMatrix +ComplexMatrix::map (cmapper fcn) const +{ + return MArray2<Complex>::map<Complex> (func_ptr (fcn)); } boolMatrix -ComplexMatrix::map (b_c_Mapper f) const +ComplexMatrix::map (bmapper fcn) const { - octave_idx_type nr = rows (); - octave_idx_type nc = cols (); - - boolMatrix retval (nr, nc); - - for (octave_idx_type j = 0; j < nc; j++) - for (octave_idx_type i = 0; i < nr; i++) - retval(i,j) = f (elem(i,j)); - - return retval; -} - -ComplexMatrix& -ComplexMatrix::apply (c_c_Mapper f) -{ - Complex *d = fortran_vec (); // Ensures only one reference to my privates! - - for (octave_idx_type i = 0; i < length (); i++) - d[i] = f (d[i]); - - return *this; + return MArray2<Complex>::map<bool> (func_ptr (fcn)); } bool
--- a/liboctave/CMatrix.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/CMatrix.h Wed Feb 20 04:22:50 2008 -0500 @@ -311,11 +311,13 @@ // other operations - ComplexMatrix map (c_c_Mapper f) const; - Matrix map (d_c_Mapper f) const; - boolMatrix map (b_c_Mapper f) const; + typedef double (*dmapper) (const Complex&); + typedef Complex (*cmapper) (const Complex&); + typedef bool (*bmapper) (const Complex&); - ComplexMatrix& apply (c_c_Mapper f); + Matrix map (dmapper fcn) const; + ComplexMatrix map (cmapper fcn) const; + boolMatrix map (bmapper fcn) const; bool any_element_is_inf_or_nan (void) const; bool all_elements_are_real (void) const;
--- a/liboctave/CNDArray.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/CNDArray.cc Wed Feb 20 04:22:50 2008 -0500 @@ -33,6 +33,7 @@ #include "CNDArray.h" #include "mx-base.h" #include "f77-fcn.h" +#include "functor.h" #include "lo-ieee.h" #include "lo-mappers.h" @@ -984,6 +985,23 @@ return ::compute_index (ra_idx, dimensions); } +NDArray +ComplexNDArray::map (dmapper fcn) const +{ + return MArrayN<Complex>::map<double> (func_ptr (fcn)); +} + +ComplexNDArray +ComplexNDArray::map (cmapper fcn) const +{ + return MArrayN<Complex>::map<Complex> (func_ptr (fcn)); +} + +boolNDArray +ComplexNDArray::map (bmapper fcn) const +{ + return MArrayN<Complex>::map<bool> (func_ptr (fcn)); +} // This contains no information on the array structure !!! std::ostream&
--- a/liboctave/CNDArray.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/CNDArray.h Wed Feb 20 04:22:50 2008 -0500 @@ -116,6 +116,14 @@ // bool all_elements_are_real (void) const; // bool all_integers (double& max_val, double& min_val) const; + typedef double (*dmapper) (const Complex&); + typedef Complex (*cmapper) (const Complex&); + typedef bool (*bmapper) (const Complex&); + + NDArray map (dmapper fcn) const; + ComplexNDArray map (cmapper fcn) const; + boolNDArray map (bmapper fcn) const; + private: ComplexNDArray (Complex *d, const dim_vector& dv)
--- a/liboctave/CRowVector.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/CRowVector.cc Wed Feb 20 04:22:50 2008 -0500 @@ -30,6 +30,7 @@ #include "Array-util.h" #include "f77-fcn.h" +#include "functor.h" #include "lo-error.h" #include "mx-base.h" #include "mx-inlines.cc" @@ -366,39 +367,16 @@ // other operations -ComplexRowVector -ComplexRowVector::map (c_c_Mapper f) const +RowVector +ComplexRowVector::map (dmapper fcn) const { - ComplexRowVector b (*this); - return b.apply (f); + return MArray<Complex>::map<double> (func_ptr (fcn)); } -RowVector -ComplexRowVector::map (d_c_Mapper f) const +ComplexRowVector +ComplexRowVector::map (cmapper fcn) const { - const Complex *d = data (); - - octave_idx_type len = length (); - - RowVector retval (len); - - double *r = retval.fortran_vec (); - - for (octave_idx_type i = 0; i < len; i++) - r[i] = f (d[i]); - - return retval; -} - -ComplexRowVector& -ComplexRowVector::apply (c_c_Mapper f) -{ - Complex *d = fortran_vec (); // Ensures only one reference to my privates! - - for (octave_idx_type i = 0; i < length (); i++) - d[i] = f (d[i]); - - return *this; + return MArray<Complex>::map<Complex> (func_ptr (fcn)); } Complex
--- a/liboctave/CRowVector.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/CRowVector.h Wed Feb 20 04:22:50 2008 -0500 @@ -96,10 +96,11 @@ // other operations - ComplexRowVector map (c_c_Mapper f) const; - RowVector map (d_c_Mapper f) const; + typedef double (*dmapper) (const Complex&); + typedef Complex (*cmapper) (const Complex&); - ComplexRowVector& apply (c_c_Mapper f); + RowVector map (dmapper fcn) const; + ComplexRowVector map (cmapper fcn) const; Complex min (void) const; Complex max (void) const;
--- a/liboctave/CSparse.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/CSparse.cc Wed Feb 20 04:22:50 2008 -0500 @@ -7177,163 +7177,6 @@ // other operations -SparseComplexMatrix -SparseComplexMatrix::map (c_c_Mapper f) const -{ - octave_idx_type nr = rows (); - octave_idx_type nc = cols (); - octave_idx_type nz = nnz (); - bool f_zero = (f(0.0) == 0.0); - - // Count number of non-zero elements - octave_idx_type nel = (f_zero ? 0 : nr*nc - nz); - for (octave_idx_type i = 0; i < nz; i++) - if (f (data(i)) != 0.0) - nel++; - - SparseComplexMatrix retval (nr, nc, nel); - - if (f_zero) - { - octave_idx_type ii = 0; - for (octave_idx_type j = 0; j < nc; j++) - { - for (octave_idx_type i = 0; i < nr; i++) - { - Complex tmp = f (elem (i, j)); - if (tmp != 0.0) - { - retval.data(ii) = tmp; - retval.ridx(ii++) = i; - } - } - retval.cidx(j+1) = ii; - } - } - else - { - octave_idx_type ii = 0; - for (octave_idx_type j = 0; j < nc; j++) - { - for (octave_idx_type i = cidx(j); i < cidx(j+1); i++) - { - retval.data(ii) = f (elem(i)); - retval.ridx(ii++) = ridx(i); - } - retval.cidx(j+1) = ii; - } - } - - return retval; -} - -SparseMatrix -SparseComplexMatrix::map (d_c_Mapper f) const -{ - octave_idx_type nr = rows (); - octave_idx_type nc = cols (); - octave_idx_type nz = nnz (); - bool f_zero = (f(0.0) == 0.0); - - // Count number of non-zero elements - octave_idx_type nel = (f_zero ? 0 : nr*nc - nz); - for (octave_idx_type i = 0; i < nz; i++) - if (f (data(i)) != 0.0) - nel++; - - SparseMatrix retval (nr, nc, nel); - - if (f_zero) - { - octave_idx_type ii = 0; - for (octave_idx_type j = 0; j < nc; j++) - { - for (octave_idx_type i = 0; i < nr; i++) - { - double tmp = f (elem (i, j)); - if (tmp != 0.0) - { - retval.data(ii) = tmp; - retval.ridx(ii++) = i; - } - } - retval.cidx(j+1) = ii; - } - } - else - { - octave_idx_type ii = 0; - for (octave_idx_type j = 0; j < nc; j++) - { - for (octave_idx_type i = cidx(j); i < cidx(j+1); i++) - { - retval.data(ii) = f (elem(i)); - retval.ridx(ii++) = ridx(i); - } - retval.cidx(j+1) = ii; - } - } - - return retval; -} - -SparseBoolMatrix -SparseComplexMatrix::map (b_c_Mapper f) const -{ - octave_idx_type nr = rows (); - octave_idx_type nc = cols (); - octave_idx_type nz = nnz (); - bool f_zero = f(0.0); - - // Count number of non-zero elements - octave_idx_type nel = (f_zero ? 0 : nr*nc - nz); - for (octave_idx_type i = 0; i < nz; i++) - if (f (data(i)) != 0.0) - nel++; - - SparseBoolMatrix retval (nr, nc, nel); - - if (f_zero) - { - octave_idx_type ii = 0; - for (octave_idx_type j = 0; j < nc; j++) - { - for (octave_idx_type i = 0; i < nr; i++) - { - bool tmp = f (elem (i, j)); - if (tmp) - { - retval.data(ii) = tmp; - retval.ridx(ii++) = i; - } - } - retval.cidx(j+1) = ii; - } - } - else - { - octave_idx_type ii = 0; - for (octave_idx_type j = 0; j < nc; j++) - { - for (octave_idx_type i = cidx(j); i < cidx(j+1); i++) - { - retval.data(ii) = f (elem(i)); - retval.ridx(ii++) = ridx(i); - } - retval.cidx(j+1) = ii; - } - } - - return retval; -} - -SparseComplexMatrix& -SparseComplexMatrix::apply (c_c_Mapper f) -{ - *this = map (f); - return *this; -} - bool SparseComplexMatrix::any_element_is_inf_or_nan (void) const { @@ -7599,6 +7442,169 @@ return d; } +SparseMatrix +SparseComplexMatrix::map (dmapper fcn) const +{ + SparseMatrix result; + double f_zero = fcn (0.); + + if (f_zero != 0.) + { + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseMatrix (nr, nc, f_zero); + + for (octave_idx_type j = 0; j < nc; j++) + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + OCTAVE_QUIT; + /* Use data instead of elem for better performance. */ + result.data (ridx (i) + j * nr) = fcn (data(i)); + } + + result.maybe_compress (true); + } + else + { + octave_idx_type nz = nnz (); + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseMatrix (nr, nc, nz); + octave_idx_type ii = 0; + result.cidx (ii) = 0; + + for (octave_idx_type j = 0; j < nc; j++) + { + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + double val = fcn (data (i)); + if (val != 0.0) + { + result.data (ii) = val; + result.ridx (ii++) = ridx (i); + } + OCTAVE_QUIT; + } + result.cidx (j+1) = ii; + } + + result.maybe_compress (false); + } + + return result; +} + +SparseComplexMatrix +SparseComplexMatrix::map (cmapper fcn) const +{ + SparseComplexMatrix result; + Complex f_zero = fcn (0.); + + if (f_zero != 0.) + { + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseComplexMatrix (nr, nc, f_zero); + + for (octave_idx_type j = 0; j < nc; j++) + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + OCTAVE_QUIT; + /* Use data instead of elem for better performance. */ + result.data (ridx (i) + j * nr) = fcn (data(i)); + } + + result.maybe_compress (true); + } + else + { + octave_idx_type nz = nnz (); + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseComplexMatrix (nr, nc, nz); + Complex zero = Complex (0.0, 0.0); + octave_idx_type ii = 0; + result.cidx (ii) = 0; + + for (octave_idx_type j = 0; j < nc; j++) + { + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + Complex val = fcn (data (i)); + if (val != zero) + { + result.data (ii) = val; + result.ridx (ii++) = ridx (i); + } + OCTAVE_QUIT; + } + result.cidx (j+1) = ii; + } + + result.maybe_compress (false); + } + + return result; +} + +SparseBoolMatrix +SparseComplexMatrix::map (bmapper fcn) const +{ + SparseBoolMatrix result; + bool f_zero = fcn (0.); + + if (f_zero) + { + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseBoolMatrix (nr, nc, f_zero); + + for (octave_idx_type j = 0; j < nc; j++) + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + OCTAVE_QUIT; + /* Use data instead of elem for better performance. */ + result.data (ridx (i) + j * nr) = fcn (data(i)); + } + + result.maybe_compress (true); + } + else + { + octave_idx_type nz = nnz (); + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseBoolMatrix (nr, nc, nz); + octave_idx_type ii = 0; + result.cidx (ii) = 0; + + for (octave_idx_type j = 0; j < nc; j++) + { + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + bool val = fcn (data (i)); + if (val) + { + result.data (ii) = val; + result.ridx (ii++) = ridx (i); + } + OCTAVE_QUIT; + } + result.cidx (j+1) = ii; + } + + result.maybe_compress (false); + } + + return result; +} + std::ostream& operator << (std::ostream& os, const SparseComplexMatrix& a) {
--- a/liboctave/CSparse.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/CSparse.h Wed Feb 20 04:22:50 2008 -0500 @@ -402,12 +402,6 @@ SparseComplexMatrix ipermute (const Array<octave_idx_type>& vec) const; - SparseComplexMatrix map (c_c_Mapper f) const; - SparseMatrix map (d_c_Mapper f) const; - SparseBoolMatrix map (b_c_Mapper f) const; - - SparseComplexMatrix& apply (c_c_Mapper f); - bool any_element_is_inf_or_nan (void) const; bool all_elements_are_real (void) const; bool all_integers (double& max_val, double& min_val) const; @@ -432,6 +426,13 @@ const SparseComplexMatrix& a); friend OCTAVE_API std::istream& operator >> (std::istream& is, SparseComplexMatrix& a); + + typedef double (*dmapper) (const Complex&); + typedef Complex (*cmapper) (const Complex&); + typedef bool (*bmapper) (const Complex&); + SparseMatrix map (dmapper fcn) const; + SparseComplexMatrix map (cmapper fcn) const; + SparseBoolMatrix map (bmapper fcn) const; }; extern OCTAVE_API SparseComplexMatrix operator * (const SparseMatrix&,
--- a/liboctave/ChangeLog Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/ChangeLog Wed Feb 20 04:22:50 2008 -0500 @@ -1,3 +1,59 @@ +2008-02-20 John W. Eaton <jwe@octave.org> + + * boolNDArray.h (boolNDArray (const Array2<bool>&)): Delete. + + * Marray2.h (MArray2 (const Array2<U>&), + MArray2 (const MArray2<U>&)): New templated constructors. + + * Array2.h (Array2 (const Array<U>&), + Array2 (const Array<U>&, const dim_vector&)): + New templated constructors. + + * CColVector.cc (ComplexColumnVector::map): Forward to MArray::map. + * dColVector.cc (ColumnVector::map): ditto. + * CRowVector.cc (ComplexRowVector::map): ditto. + * dRowVector.cc (RowVector::map): ditto. + * CMatrix.cc (ComplexMatrix::map): Forward to MArray2::map. + * dMatrix.cc (Matrix::map): ditto. + + * dNDArray.cc (NDArray::map): New functions. + * dNDArray.h: Provide decls. + + * CNDArray.cc (ComplexNDArray::map): New functions. + * CNDArray.h: Provide decls. + + * MArray2.h (MArray2<T>::map): New function. + * Array2.h (Array2<T>::map): New function. + * MArrayN.h (MArrayN<T>::map): New function. + * ArrayN.h (ArrayN<T>::map): New function. + * Array.h (Array<T>::map): New function. + + * functor.h: New file. + * Makefile.in (INCLUDES): Add it to the list. + +2008-02-20 David Bateman <dbateman@free.fr> + + * CColVector.h, CColVector.cc (ComplexColumnVector::apply): Remove. + * dColVector.h, dColVector.cc (ColumnVector::apply): ditto. + * CRowVector.h, CRowVector.cc (ComplexRowVector::apply): ditto. + * dRowVector.h, dRowVector.cc (RowVector::apply): ditto. + * CMatrix.h, CMatrix.cc (ComplexMatrix::apply): ditto. + * dMatrix.h, dMatrix.cc (Matrix::apply): ditto. + + * CSparse.cc (apply): Remove. + (map): Replace old mapper code with code taken from ov-mapepr.cc + * CSparse.h (map): Reeclare them. + (dmapper, cmapper, bmapper): typedefs for mapper functions. + * dSparse.cc (apply): Remove. + (map): Replace old mapper code with code taken from ov-mapepr.cc + * dSparse.h (map): Reeclare them. + (dmapper, cmapper, bmapper): typedefs for mapper functions. + + * intNDArray.cc (abs, signum): Two new mapper functions. + * intNDArray.h (abs, signum): Declare them. + * oct-inttypes.h (abs, signum): Mapper functions on scalar integer + base type. + 2008-02-15 John W. Eaton <jwe@octave.org> * dMatrix.cc (Matrix::lssolve): Check n > mnthr, not n > m when
--- a/liboctave/MArray.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/MArray.h Wed Feb 20 04:22:50 2008 -0500 @@ -82,6 +82,12 @@ double norm (double p) const; + template <class U, class F> + MArray<U> map (F fcn) const + { + return Array<T>::template map<U> (fcn); + } + // Currently, the OPS functions don't need to be friends, but that // may change.
--- a/liboctave/MArray2.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/MArray2.h Wed Feb 20 04:22:50 2008 -0500 @@ -59,6 +59,12 @@ MArray2 (const Array2<T>& a) : Array2<T> (a) { } + template <class U> + MArray2 (const Array2<U>& a) : Array2<T> (a) { } + + template <class U> + MArray2 (const MArray2<U>& a) : Array2<T> (a) { } + ~MArray2 (void) { } MArray2<T>& operator = (const MArray2<T>& a) @@ -75,6 +81,12 @@ MArray2<T> transpose (void) const { return Array2<T>::transpose (); } + template <class U, class F> + MArray2<U> map (F fcn) const + { + return Array2<T>::template map<U> (fcn); + } + // Currently, the OPS functions don't need to be friends, but that // may change.
--- a/liboctave/MArrayN.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/MArrayN.h Wed Feb 20 04:22:50 2008 -0500 @@ -97,6 +97,12 @@ { return ArrayN<T>::ipermute (vec); } MArrayN squeeze (void) const { return ArrayN<T>::squeeze (); } + + template <class U, class F> + MArrayN<U> map (F fcn) const + { + return ArrayN<T>::template map<U> (fcn); + } }; #endif
--- a/liboctave/Makefile.in Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/Makefile.in Wed Feb 20 04:22:50 2008 -0500 @@ -76,7 +76,7 @@ NLFunc.h NLP.h ODE.h ODEFunc.h ODES.h ODESFunc.h \ Objective.h QP.h Quad.h Range.h base-dae.h \ base-de.h base-min.h byte-swap.h cmd-edit.h cmd-hist.h \ - data-conv.h dir-ops.h file-ops.h file-stat.h getopt.h \ + data-conv.h dir-ops.h file-ops.h file-stat.h functor.h getopt.h \ glob-match.h idx-vector.h kpse-xfns.h \ lo-ieee.h lo-mappers.h lo-math.h lo-specfun.h \ lo-sysdep.h lo-utils.h mach-info.h md5.h oct-alloc.h oct-cmplx.h \
--- a/liboctave/boolNDArray.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/boolNDArray.h Wed Feb 20 04:22:50 2008 -0500 @@ -47,8 +47,6 @@ boolNDArray (const boolMatrix& a) : ArrayN<bool> (a) { } - boolNDArray (const Array2<bool>& a) : ArrayN<bool> (a) { } - boolNDArray (const ArrayN<bool>& a) : ArrayN<bool> (a) { } boolNDArray& operator = (const boolNDArray& a)
--- a/liboctave/chNDArray.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/chNDArray.cc Wed Feb 20 04:22:50 2008 -0500 @@ -145,6 +145,60 @@ return ::compute_index (ra_idx, dimensions); } +boolNDArray +charNDArray::bmap (mapper fcn) const +{ + octave_idx_type len = length (); + const char *m = fortran_vec(); + boolNDArray result (dims ()); + bool *p = result.fortran_vec (); + + for (octave_idx_type i = 0; i < len; i++) + { + OCTAVE_QUIT; + + p[i] = bool (fcn (m[i])); + } + + return result; +} + +NDArray +charNDArray::dmap (mapper fcn) const +{ + octave_idx_type len = length (); + const char *m = fortran_vec(); + NDArray result (dims ()); + double *p = result.fortran_vec (); + + for (octave_idx_type i = 0; i < len; i++) + { + OCTAVE_QUIT; + + p[i] = fcn (m[i]); + } + + return result; +} + +charNDArray +charNDArray::smap (mapper fcn) const +{ + octave_idx_type len = length (); + const char *m = fortran_vec(); + charNDArray result (dims ()); + char *p = result.fortran_vec (); + + for (octave_idx_type i = 0; i < len; i++) + { + OCTAVE_QUIT; + + p[i] = fcn (m[i]); + } + + return result; +} + NDS_CMP_OPS(charNDArray, , char, ) NDS_BOOL_OPS(charNDArray, char, 0)
--- a/liboctave/chNDArray.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/chNDArray.h Wed Feb 20 04:22:50 2008 -0500 @@ -89,6 +89,11 @@ static char resize_fill_value (void) { return '\0'; } + typedef int (*mapper) (int); + boolNDArray bmap (mapper fcn) const; + NDArray dmap (mapper fcn) const; + charNDArray smap (mapper fcn) const; + private: charNDArray (char *d, dim_vector& dv) : MArrayN<char> (d, dv) { }
--- a/liboctave/dColVector.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/dColVector.cc Wed Feb 20 04:22:50 2008 -0500 @@ -30,6 +30,7 @@ #include "Array-util.h" #include "f77-fcn.h" +#include "functor.h" #include "lo-error.h" #include "mx-base.h" #include "mx-inlines.cc" @@ -263,21 +264,15 @@ // other operations ColumnVector -ColumnVector::map (d_d_Mapper f) const +ColumnVector::map (dmapper fcn) const { - ColumnVector b (*this); - return b.apply (f); + return MArray<double>::map<double> (func_ptr (fcn)); } -ColumnVector& -ColumnVector::apply (d_d_Mapper f) +ComplexColumnVector +ColumnVector::map (cmapper fcn) const { - double *d = fortran_vec (); // Ensures only one reference to my privates! - - for (octave_idx_type i = 0; i < length (); i++) - d[i] = f (d[i]); - - return *this; + return MArray<double>::map<Complex> (func_ptr (fcn)); } double
--- a/liboctave/dColVector.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/dColVector.h Wed Feb 20 04:22:50 2008 -0500 @@ -83,9 +83,11 @@ // other operations - ColumnVector map (d_d_Mapper f) const; + typedef double (*dmapper) (double); + typedef Complex (*cmapper) (const Complex&); - ColumnVector& apply (d_d_Mapper f); + ColumnVector map (dmapper fcn) const; + ComplexColumnVector map (cmapper fcn) const; double min (void) const; double max (void) const;
--- a/liboctave/dMatrix.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/dMatrix.cc Wed Feb 20 04:22:50 2008 -0500 @@ -40,6 +40,7 @@ #include "dbleSVD.h" #include "dbleCHOL.h" #include "f77-fcn.h" +#include "functor.h" #include "lo-error.h" #include "lo-ieee.h" #include "lo-mappers.h" @@ -2623,36 +2624,21 @@ // other operations. Matrix -Matrix::map (d_d_Mapper f) const +Matrix::map (dmapper fcn) const { - Matrix b (*this); - return b.apply (f); + return MArray2<double>::map<double> (func_ptr (fcn)); +} + +ComplexMatrix +Matrix::map (cmapper fcn) const +{ + return MArray2<double>::map<Complex> (func_ptr (fcn)); } boolMatrix -Matrix::map (b_d_Mapper f) const +Matrix::map (bmapper fcn) const { - octave_idx_type nr = rows (); - octave_idx_type nc = cols (); - - boolMatrix retval (nr, nc); - - for (octave_idx_type j = 0; j < nc; j++) - for (octave_idx_type i = 0; i < nr; i++) - retval(i,j) = f (elem(i,j)); - - return retval; -} - -Matrix& -Matrix::apply (d_d_Mapper f) -{ - double *d = fortran_vec (); // Ensures only one reference to my privates! - - for (octave_idx_type i = 0; i < length (); i++) - d[i] = f (d[i]); - - return *this; + return MArray2<double>::map<bool> (func_ptr (fcn)); } bool
--- a/liboctave/dMatrix.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/dMatrix.h Wed Feb 20 04:22:50 2008 -0500 @@ -266,10 +266,13 @@ // other operations - Matrix map (d_d_Mapper f) const; - boolMatrix map (b_d_Mapper f) const; + typedef double (*dmapper) (double); + typedef Complex (*cmapper) (const Complex&); + typedef bool (*bmapper) (double); - Matrix& apply (d_d_Mapper f); + Matrix map (dmapper fcn) const; + ComplexMatrix map (cmapper fcn) const; + boolMatrix map (bmapper fcn) const; bool any_element_is_negative (bool = false) const; bool any_element_is_inf_or_nan (void) const;
--- a/liboctave/dNDArray.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/dNDArray.cc Wed Feb 20 04:22:50 2008 -0500 @@ -31,6 +31,7 @@ #include "Array-util.h" #include "dNDArray.h" +#include "functor.h" #include "mx-base.h" #include "f77-fcn.h" #include "lo-error.h" @@ -960,6 +961,24 @@ return ::compute_index (ra_idx, dimensions); } +NDArray +NDArray::map (dmapper fcn) const +{ + return MArrayN<double>::map<double> (func_ptr (fcn)); +} + +ComplexNDArray +NDArray::map (cmapper fcn) const +{ + return MArrayN<double>::map<Complex> (func_ptr (fcn)); +} + +boolNDArray +NDArray::map (bmapper fcn) const +{ + return MArrayN<double>::map<bool> (func_ptr (fcn)); +} + // This contains no information on the array structure !!! std::ostream& operator << (std::ostream& os, const NDArray& a)
--- a/liboctave/dNDArray.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/dNDArray.h Wed Feb 20 04:22:50 2008 -0500 @@ -124,6 +124,14 @@ static double resize_fill_value (void) { return 0; } + typedef double (*dmapper) (double); + typedef Complex (*cmapper) (const Complex&); + typedef bool (*bmapper) (double); + + NDArray map (dmapper fcn) const; + ComplexNDArray map (cmapper fcn) const; + boolNDArray map (bmapper fcn) const; + private: NDArray (double *d, const dim_vector& dv) : MArrayN<double> (d, dv) { }
--- a/liboctave/dRowVector.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/dRowVector.cc Wed Feb 20 04:22:50 2008 -0500 @@ -30,6 +30,7 @@ #include "Array-util.h" #include "f77-fcn.h" +#include "functor.h" #include "lo-error.h" #include "mx-base.h" #include "mx-inlines.cc" @@ -232,21 +233,15 @@ // other operations RowVector -RowVector::map (d_d_Mapper f) const +RowVector::map (dmapper fcn) const { - RowVector b (*this); - return b.apply (f); + return MArray<double>::map<double> (func_ptr (fcn)); } -RowVector& -RowVector::apply (d_d_Mapper f) +ComplexRowVector +RowVector::map (cmapper fcn) const { - double *d = fortran_vec (); // Ensures only one reference to my privates! - - for (octave_idx_type i = 0; i < length (); i++) - d[i] = f (d[i]); - - return *this; + return MArray<double>::map<Complex> (func_ptr (fcn)); } double
--- a/liboctave/dRowVector.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/dRowVector.h Wed Feb 20 04:22:50 2008 -0500 @@ -79,9 +79,11 @@ // other operations - RowVector map (d_d_Mapper f) const; + typedef double (*dmapper) (double); + typedef Complex (*cmapper) (const Complex&); - RowVector& apply (d_d_Mapper f); + RowVector map (dmapper fcn) const; + ComplexRowVector map (cmapper fcn) const; double min (void) const; double max (void) const;
--- a/liboctave/dSparse.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/dSparse.cc Wed Feb 20 04:22:50 2008 -0500 @@ -7214,113 +7214,6 @@ // other operations. -SparseMatrix -SparseMatrix::map (d_d_Mapper f) const -{ - octave_idx_type nr = rows (); - octave_idx_type nc = cols (); - octave_idx_type nz = nnz (); - bool f_zero = (f(0.0) == 0.0); - - // Count number of non-zero elements - octave_idx_type nel = (f_zero ? 0 : nr*nc - nz); - for (octave_idx_type i = 0; i < nz; i++) - if (f (data(i)) != 0.0) - nel++; - - SparseMatrix retval (nr, nc, nel); - - if (f_zero) - { - octave_idx_type ii = 0; - for (octave_idx_type j = 0; j < nc; j++) - { - for (octave_idx_type i = 0; i < nr; i++) - { - double tmp = f (elem (i, j)); - if (tmp != 0.0) - { - retval.data(ii) = tmp; - retval.ridx(ii++) = i; - } - } - retval.cidx(j+1) = ii; - } - } - else - { - octave_idx_type ii = 0; - for (octave_idx_type j = 0; j < nc; j++) - { - for (octave_idx_type i = cidx(j); i < cidx(j+1); i++) - { - retval.data(ii) = f (elem(i)); - retval.ridx(ii++) = ridx(i); - } - retval.cidx(j+1) = ii; - } - } - - return retval; -} - -SparseBoolMatrix -SparseMatrix::map (b_d_Mapper f) const -{ - octave_idx_type nr = rows (); - octave_idx_type nc = cols (); - octave_idx_type nz = nnz (); - bool f_zero = f(0.0); - - // Count number of non-zero elements - octave_idx_type nel = (f_zero ? 0 : nr*nc - nz); - for (octave_idx_type i = 0; i < nz; i++) - if (f (data(i)) != 0.0) - nel++; - - SparseBoolMatrix retval (nr, nc, nel); - - if (f_zero) - { - octave_idx_type ii = 0; - for (octave_idx_type j = 0; j < nc; j++) - { - for (octave_idx_type i = 0; i < nr; i++) - { - bool tmp = f (elem (i, j)); - if (tmp) - { - retval.data(ii) = tmp; - retval.ridx(ii++) = i; - } - } - retval.cidx(j+1) = ii; - } - } - else - { - octave_idx_type ii = 0; - for (octave_idx_type j = 0; j < nc; j++) - { - for (octave_idx_type i = cidx(j); i < cidx(j+1); i++) - { - retval.data(ii) = f (elem(i)); - retval.ridx(ii++) = ridx(i); - } - retval.cidx(j+1) = ii; - } - } - - return retval; -} - -SparseMatrix& -SparseMatrix::apply (d_d_Mapper f) -{ - *this = map (f); - return *this; -} - bool SparseMatrix::any_element_is_negative (bool neg_zero) const { @@ -7641,6 +7534,169 @@ return retval; } +SparseMatrix +SparseMatrix::map (dmapper fcn) const +{ + SparseMatrix result; + double f_zero = fcn (0.); + + if (f_zero != 0.) + { + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseMatrix (nr, nc, f_zero); + + for (octave_idx_type j = 0; j < nc; j++) + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + OCTAVE_QUIT; + /* Use data instead of elem for better performance. */ + result.data (ridx (i) + j * nr) = fcn (data(i)); + } + + result.maybe_compress (true); + } + else + { + octave_idx_type nz = nnz (); + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseMatrix (nr, nc, nz); + octave_idx_type ii = 0; + result.cidx (ii) = 0; + + for (octave_idx_type j = 0; j < nc; j++) + { + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + double val = fcn (data (i)); + if (val != 0.0) + { + result.data (ii) = val; + result.ridx (ii++) = ridx (i); + } + OCTAVE_QUIT; + } + result.cidx (j+1) = ii; + } + + result.maybe_compress (false); + } + + return result; +} + +SparseComplexMatrix +SparseMatrix::map (cmapper fcn) const +{ + SparseComplexMatrix result; + Complex f_zero = fcn (0.); + + if (f_zero != 0.) + { + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseComplexMatrix (nr, nc, f_zero); + + for (octave_idx_type j = 0; j < nc; j++) + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + OCTAVE_QUIT; + /* Use data instead of elem for better performance. */ + result.data (ridx (i) + j * nr) = fcn (Complex (data(i), 0.0)); + } + + result.maybe_compress (true); + } + else + { + octave_idx_type nz = nnz (); + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseComplexMatrix (nr, nc, nz); + Complex zero = Complex (0.0, 0.0); + octave_idx_type ii = 0; + result.cidx (ii) = 0; + + for (octave_idx_type j = 0; j < nc; j++) + { + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + Complex val = fcn (Complex (data (i), 0.0)); + if (val != zero) + { + result.data (ii) = val; + result.ridx (ii++) = ridx (i); + } + OCTAVE_QUIT; + } + result.cidx (j+1) = ii; + } + + result.maybe_compress (false); + } + + return result; +} + +SparseBoolMatrix +SparseMatrix::map (bmapper fcn) const +{ + SparseBoolMatrix result; + bool f_zero = fcn (0.); + + if (f_zero) + { + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseBoolMatrix (nr, nc, f_zero); + + for (octave_idx_type j = 0; j < nc; j++) + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + OCTAVE_QUIT; + /* Use data instead of elem for better performance. */ + result.data (ridx (i) + j * nr) = fcn (data(i)); + } + + result.maybe_compress (true); + } + else + { + octave_idx_type nz = nnz (); + octave_idx_type nr = rows (); + octave_idx_type nc = cols (); + + result = SparseBoolMatrix (nr, nc, nz); + octave_idx_type ii = 0; + result.cidx (ii) = 0; + + for (octave_idx_type j = 0; j < nc; j++) + { + for (octave_idx_type i = cidx(j); i < cidx (j+1); i++) + { + bool val = fcn (data (i)); + if (val) + { + result.data (ii) = val; + result.ridx (ii++) = ridx (i); + } + OCTAVE_QUIT; + } + result.cidx (j+1) = ii; + } + + result.maybe_compress (false); + } + + return result; +} + std::ostream& operator << (std::ostream& os, const SparseMatrix& a) {
--- a/liboctave/dSparse.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/dSparse.h Wed Feb 20 04:22:50 2008 -0500 @@ -370,10 +370,6 @@ solve_singularity_handler sing_handler) const; // other operations - SparseMatrix map (d_d_Mapper f) const; - SparseBoolMatrix map (b_d_Mapper f) const; - - SparseMatrix& apply (d_d_Mapper f); bool any_element_is_negative (bool = false) const; bool any_element_is_inf_or_nan (void) const; @@ -416,6 +412,13 @@ friend OCTAVE_API std::ostream& operator << (std::ostream& os, const SparseMatrix& a); friend OCTAVE_API std::istream& operator >> (std::istream& is, SparseMatrix& a); + + typedef double (*dmapper) (double); + typedef Complex (*cmapper) (const Complex&); + typedef bool (*bmapper) (double); + SparseMatrix map (dmapper fcn) const; + SparseComplexMatrix map (cmapper fcn) const; + SparseBoolMatrix map (bmapper fcn) const; }; // Publish externally used friend functions.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/liboctave/functor.h Wed Feb 20 04:22:50 2008 -0500 @@ -0,0 +1,81 @@ +/* + +Copyright (C) 2008 John W. Eaton + +This file is part of Octave. + +Octave 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 3 of the License, or (at your +option) any later version. + +Octave 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 Octave; see the file COPYING. If not, see +<http://www.gnu.org/licenses/>. + +*/ + +#if !defined (octave_functor_h) +#define octave_functor_h 1 + +template <typename RT, typename PT> +class fcn_ptr +{ +public: + typedef RT (*TYPE) (PT); +}; + +template <typename RT, typename PT> +class functor +{ +private: + typedef typename fcn_ptr<RT, PT>::TYPE fcn_ptr_type; + fcn_ptr_type fptr; + +public: + + functor (fcn_ptr_type p) : fptr (p) { } + + RT operator () (PT arg) { return fptr (arg); } +}; + +template <typename CT, typename RT, typename PT> +class functor_with_conversion +{ +private: + typedef typename fcn_ptr<RT, PT>::TYPE fcn_ptr_type; + fcn_ptr_type fptr; + +public: + + functor_with_conversion (fcn_ptr_type p) : fptr (p) { } + + CT operator () (PT arg) { return CT (fptr (arg)); } +}; + +template <typename RT, typename PT> +functor<RT, PT> +func_ptr (RT (*f) (PT)) +{ + return functor<RT, PT> (f); +} + +template <typename CT, typename RT, typename PT> +functor_with_conversion<CT, RT, PT> +func_ptr_with_conversion (RT (*f) (PT)) +{ + return functor_with_conversion<CT, RT, PT> (f); +} + +#endif + +/* +;;; Local Variables: *** +;;; mode: C++ *** +;;; End: *** +*/
--- a/liboctave/intNDArray.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/intNDArray.cc Wed Feb 20 04:22:50 2008 -0500 @@ -222,6 +222,40 @@ return is; } +// FIXME -- should abs and signum just be mapper functions? + +template <class T> +intNDArray<T> +intNDArray<T>::abs (void) const +{ + octave_idx_type nel = this->nelem (); + intNDArray<T> ret (*this); + + for (octave_idx_type i = 0; i < nel; i++) + { + T val = this->elem (i); + ret.xelem (i) = val.abs (); + } + + return ret; +} + +template <class T> +intNDArray<T> +intNDArray<T>::signum (void) const +{ + octave_idx_type nel = this->nelem (); + intNDArray<T> ret (*this); + + for (octave_idx_type i = 0; i < nel; i++) + { + T val = this->elem (i); + ret.xelem (i) = val.signum (); + } + + return ret; +} + template <class T> intNDArray<T> intNDArray<T>::sum (int dim) const
--- a/liboctave/intNDArray.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/intNDArray.h Wed Feb 20 04:22:50 2008 -0500 @@ -80,6 +80,9 @@ intNDArray sum (int dim) const; + intNDArray abs (void) const; + intNDArray signum (void) const; + intNDArray squeeze (void) const { return intNDArray<T> (MArrayN<T>::squeeze ()); }
--- a/liboctave/oct-inttypes.h Wed Feb 20 01:09:19 2008 -0500 +++ b/liboctave/oct-inttypes.h Wed Feb 20 04:22:50 2008 -0500 @@ -316,6 +316,24 @@ return *this; } + octave_int<T> abs (void) const + { + T val = value (); + if (val < static_cast <T> (0)) + val = - val; + return val; + } + + octave_int<T> signum (void) const + { + T val = value (); + if (val < static_cast <T> (0)) + val = - static_cast <T> (1); + else if (val > static_cast <T> (0)) + val = static_cast <T> (1); + return val; + } + octave_int<T> min (void) const { return std::numeric_limits<T>::min (); } octave_int<T> max (void) const { return std::numeric_limits<T>::max (); }
--- a/src/ChangeLog Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ChangeLog Wed Feb 20 04:22:50 2008 -0500 @@ -1,3 +1,136 @@ +2008-02-20 John W. Eaton <jwe@octave.org> + + * ov-bool-mat.h (octave_bool_matrix (const Array2<bool>&)): Delete. + +2008-02-20 David Bateman <dbateman@free.fr> + + * Makefile.in (OV_SRC): Remove ov-mapper.cc. + (OV_INCLUDES): Remove ov-mapper.h. + (DEFUN_PATTERN): No longer accept DEFUN_MAPPER as valid. + * ov-mapper.cc, ov-mapepr.h: Delete, remove all includes of + ov-mapper.h from all files. + + * op-b-sbm.cc, op-bm-sbm.cc, op-smb-b.cc, op-sbm-bm.cc: Include + ov-bool-sparse.h. + + * defun-int.h (DEFUN_MAPPER_INTERNAL, install_builtin_mapper): + Remove. + * defun.cc (install_builtin_mapper): Ditto. + * defun.h (DEFUN_MAPPER): Remove. + + * mappers.cc: Rewrite all mapper function using DEFUN and newly + introduced octave_value mapper functions. + (dummyp, xabs, xisalnum, xisascii, xiscntrl, xisdigit, + xisgraph, xislower, xisprint, xispunct, xisspace, xisupper, + xtoascii, xtolower, xtoupper, xconj, ximag, xreal): Remove + static wrapper functions. + + * mkbuiltins (XDEFUN_MAPPER_INTERNAL, install_builtin_functions): + Remove. + * mkgendoc (XDEFUN_MAPPER_INTERNAL): Remove. + + * ov.cc (octave_mapper::register_type): Remove. + + * ov.h (abs, acos, acosh, angle, arg, asin, asinh, atan, atanh, + ceil, conj, cos, cosh, erf, erfc, exp, finite, fix, floor, gamma, + imag, isinf, isna, isnan, lgamma, log, log10, real, round, signum, + sin, sinh, sqrt, tan, tanh, isalnum, isalpha, isascii, iscntrl, + isdigit, isgraph, islower, isprint, ispunct, isspace, isupper, + isxdigit, toascii, tolower, toupper): + New octave_value mapper functions. + + * ov-base.h (abs, acos, acosh, angle, arg, asin, asinh, atan, + atanh, ceil, conj, cos, cosh, erf, erfc, exp, finite, fix, floor, + gamma, imag, isinf, isna, isnan, lgamma, log, log10, real, round, + signum, sin, sinh, sqrt, tan, tanh, isalnum, isalpha, isascii, + iscntrl, isdigit, isgraph, slower, isprint, ispunct, isspace, + isupper, isxdigit, toascii, tolower, toupper): + New virtual mapper functions. + * ov-base.cc (abs, acos, acosh, angle, arg, asin, asinh, atan, + atanh, ceil, conj, cos, cosh, erf, erfc, exp, finite, fix, floor, + gamma, imag, isinf, isna, isnan, lgamma, log, log10, real, round, + signum, sin, sinh, sqrt, tan, tanh, isalnum, isalpha, isascii, + iscntrl, isdigit, isgraph, slower, isprint, ispunct, isspace, + isupper, isxdigit, toascii, tolower, toupper): + Base versions of mapper functions. + + * ov-bool-mat.h (abs, acos, acosh, angle, arg, asin, asinh, atan, + atanh, ceil, conj, cos, cosh, erf, erfc, exp, finite, fix, floor, + gamma, imag, isinf, isna, isnan, lgamma, log, log10, real, round, + signum, sin, sinh, sqrt, tan, tanh): + Mapper function recast boolen matrix as double. + * ov-bool.h (abs, acos, acosh, angle, arg, asin, asinh, atan, + atanh, ceil, conj, cos, cosh, erf, erfc, exp, finite, fix, floor, + gamma, imag, isinf, isna, isnan, lgamma, log, log10, real, round, + signum, sin, sinh, sqrt, tan, tanh): Ditto. + * ov-bool-sparse.h (abs, acos, acosh, angle, arg, asin, asinh, + atan, atanh, ceil, conj, cos, cosh, erf, erfc, exp, finite, fix, + floor, gamma, imag, isinf, isna, isnan, lgamma, log, log10, real, + round, signum, sin, sinh, sqrt, tan, tanh): Ditto. + (char_array_value): New method to convert to charNDArray. + * ov-bool-sparse.cc (char_array_value): New method to convert to + charNDArray. + * ov-complex.cc (char_array_value): ditto. + (xabs, ximag, xreal): Static wrapper functions. + (abs, acos, acosh, angle, arg, asin, asinh, atan, atanh, ceil, + conj, cos, cosh, exp, finite, fix, floor, imag, isinf, isna, + isnan, log, log10, real, round, signum, sin, sinh, sqrt, tan, + tanh): New mapper methods. + * ov-complex.h: Provide decls. + + * ov-cx-mat.cc (char_array_value): New method to convert to + charNDArray. + (xabs, ximag, xreal): Static wrapper functions. + (abs, acos, acosh, angle, arg, asin, asinh, atan, atanh, ceil, + conj, cos, cosh, exp, finite, fix, floor, imag, isinf, isna, + isnan, log, log10, real, round, signum, sin, sinh, sqrt, tan, + tanh): New mapper methods. + * ov-cx-mat.h: Provide decls. + + * ov-cx-sparse.cc (char_array_value): New method to convert to + charNDArray. + (xabs, ximag, xreal): Static wrapper functions. + (abs, acos, acosh, angle, arg, asin, asinh, atan, atanh, ceil, + conj, cos, cosh, exp, finite, fix, floor, imag, isinf, isna, + isnan, log, log10, real, round, signum, sin, sinh, sqrt, tan, + tanh): New mapper methods. + * ov-cx-sparse.h: Provide decls. + + * ov-intx.h (abs, signum, imag, ceil, conj, fix, floor, real, + round, finite, isinf, isna, isnan): Define for both matrix and + scalar classes. + + * ov-range.h (abs, acos, acosh, angle, arg, asin, asinh, atan, + atanh, ceil, conj, cos, cosh, erf, erfc, exp, finite, fix, floor, + gamma, imag, isinf, isna, isnan, lgamma, log, log10, real, round, + signum, sin, sinh, sqrt, tan, tanh): New mapper functions. + + * ov-re-mat.cc (any_element_less_than): Static function to check if + any elemet was less than a value, + (any_element_greater_than): Ditto with greater than. + (abs, acos, acosh, angle, arg, asin, asinh, atan, atanh, ceil, + conj, cos, cosh, erf, erfc, exp, finite, fix, floor, gamma, imag, + isinf, isna, isnan, lgamma, log, log10, real, round, signum, sin, + sinh, sqrt, tan, tanh): New mapper functions. + * ov-re-mat.h: Provide decls. + + * ov-scalar.cc (any_element_less_than): Static function to check if + any elemet was less than a value, + (any_element_greater_than): ditto with greater than. + (abs acos acosh angle arg asin asinh atan atanh + ceil conj cos cosh erf erfc exp finite fix floor gamma imag + isinf isna isnan lgamma log log10 real round signum sin sinh + sqrt tan tanh): New mapper functions. + * ov-scalar.h: Provide decls. + + * ov-str-mat.cc (xisalnum, xisascii, xiscntrl, xisdigit, + xisgraph, xislower, xisprint, xispunct, xisspace, xisupper, + xtoascii, xtolower, xtoupper): New static wrapper functions. + (isalnum, isalpha, isascii, iscntrl, isdigit, isgraph, islower, + isprint, ispunct, isspace, isupper, isxdigit, toascii, tolower, + toupper): New mapper methods. + * ov-str-mat.h: Provide decls. + 2008-02-18 David Bateman <dbateman@free.fr> * data.cc (Fatan2): Reject arguments that are integer types.
--- a/src/Makefile.in Wed Feb 20 01:09:19 2008 -0500 +++ b/src/Makefile.in Wed Feb 20 04:22:50 2008 -0500 @@ -101,7 +101,7 @@ ov-colon.h ov-base.h ov-base-mat.h ov-base-scalar.h \ ov-streamoff.h ov-str-mat.h ov-bool-mat.h ov-bool.h \ ov-cell.h ov.h ov-fcn.h ov-builtin.h ov-dld-fcn.h \ - ov-mapper.h ov-mex-fcn.h ov-usr-fcn.h ov-fcn-handle.h \ + ov-mex-fcn.h ov-usr-fcn.h ov-fcn-handle.h \ ov-fcn-inline.h ov-class.h ov-typeinfo.h ov-type-conv.h \ $(OV_INTTYPE_INC) @@ -172,7 +172,7 @@ ov-range.cc ov-scalar.cc ov-complex.cc ov-str-mat.cc \ ov-streamoff.cc ov-struct.cc \ ov-colon.cc ov-bool-mat.cc ov-bool.cc ov-cell.cc \ - ov.cc ov-fcn.cc ov-builtin.cc ov-dld-fcn.cc ov-mapper.cc \ + ov.cc ov-fcn.cc ov-builtin.cc ov-dld-fcn.cc \ ov-mex-fcn.cc ov-usr-fcn.cc ov-fcn-handle.cc ov-fcn-inline.cc \ ov-class.cc ov-typeinfo.cc \ $(OV_INTTYPE_SRC) \ @@ -237,7 +237,7 @@ # so we have to repeat ourselves because some stupid egreps don't like # empty elements in alternation patterns. -DEFUN_PATTERN = "^[ \t]*DEF(CONSTFUN|CMD|UN|UN_DLD|UNX_DLD|UN_TEXT|UN_MAPPER)[ \t]*\\(" +DEFUN_PATTERN = "^[ \t]*DEF(CONSTFUN|CMD|UN|UN_DLD|UNX_DLD|UN_TEXT)[ \t]*\\(" DLD_DEF_FILES_1 := $(patsubst %.l, %.df, $(DLD_XSRC)) DLD_DEF_FILES := $(patsubst %.cc, %.df, $(DLD_DEF_FILES_1))
--- a/src/OPERATORS/op-b-sbm.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/OPERATORS/op-b-sbm.cc Wed Feb 20 04:22:50 2008 -0500 @@ -35,6 +35,7 @@ #include "ops.h" #include "ov-re-sparse.h" +#include "ov-bool-sparse.h" // bool by sparse bool matrix ops.
--- a/src/OPERATORS/op-bm-sbm.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/OPERATORS/op-bm-sbm.cc Wed Feb 20 04:22:50 2008 -0500 @@ -35,6 +35,7 @@ #include "ops.h" #include "ov-re-sparse.h" +#include "ov-bool-sparse.h" #include "smx-bm-sbm.h" #include "smx-sbm-bm.h"
--- a/src/OPERATORS/op-sbm-b.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/OPERATORS/op-sbm-b.cc Wed Feb 20 04:22:50 2008 -0500 @@ -34,6 +34,7 @@ #include "ops.h" #include "ov-re-sparse.h" +#include "ov-bool-sparse.h" // sparse bool matrix by bool ops.
--- a/src/OPERATORS/op-sbm-bm.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/OPERATORS/op-sbm-bm.cc Wed Feb 20 04:22:50 2008 -0500 @@ -35,6 +35,7 @@ #include "ops.h" #include "ov-re-sparse.h" +#include "ov-bool-sparse.h" #include "smx-bm-sbm.h" #include "smx-sbm-bm.h"
--- a/src/defun-int.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/defun-int.h Wed Feb 20 04:22:50 2008 -0500 @@ -28,7 +28,6 @@ #include "ov-builtin.h" #include "ov-dld-fcn.h" -#include "ov-mapper.h" #include "symtab.h" #include "version.h" @@ -40,9 +39,6 @@ extern OCTINTERP_API void check_version (const std::string& version, const std::string& fcn); extern OCTINTERP_API void -install_builtin_mapper (octave_mapper *mf, const std::string& name); - -extern OCTINTERP_API void install_builtin_function (octave_builtin::fcn f, const std::string& name, const std::string& doc, bool is_text_fcn = false, bool can_hide_function = true); @@ -179,15 +175,6 @@ XDEFALIAS_INTERNAL(alias, name) \ END_INSTALL_BUILTIN -#define DEFUN_MAPPER_INTERNAL(name, ch_map, d_b_map, c_b_map, d_d_map, \ - d_c_map, c_c_map, lo, hi, \ - ch_map_flag, can_ret_cmplx_for_real, doc) \ - BEGIN_INSTALL_BUILTIN \ - XDEFUN_MAPPER_INTERNAL(name, ch_map, d_b_map, c_b_map, d_d_map, \ - d_c_map, c_c_map, lo, hi, \ - ch_map_flag, can_ret_cmplx_for_real, doc) \ - END_INSTALL_BUILTIN - #else /* ! MAKE_BUILTINS */ // Generate the first line of the function definition. This ensures @@ -207,20 +194,6 @@ #define DEFALIAS_INTERNAL(alias, name) -// How mapper functions are actually installed. - -// FIXME -- Really want to avoid the following casts, since -// (as always with casts) it may mask some real errors... - -#define DEFUN_MAPPER_INTERNAL(name, ch_map, d_b_map, c_b_map, d_d_map, \ - d_c_map, c_c_map, lo, hi, \ - ch_map_flag, can_ret_cmplx_for_real, doc) \ - install_builtin_mapper \ - (new octave_mapper \ - (ch_map, d_b_map, c_b_map, d_d_map, d_c_map, c_c_map, \ - lo, hi, ch_map_flag, can_ret_cmplx_for_real, #name, doc), \ - #name) - #endif /* ! MAKE_BUILTINS */ #endif
--- a/src/defun.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/defun.cc Wed Feb 20 04:22:50 2008 -0500 @@ -37,7 +37,6 @@ #include "ov-builtin.h" #include "ov-dld-fcn.h" #include "ov-fcn.h" -#include "ov-mapper.h" #include "ov-mex-fcn.h" #include "ov-usr-fcn.h" #include "oct-obj.h" @@ -129,12 +128,6 @@ // Install variables and functions in the symbol tables. void -install_builtin_mapper (octave_mapper *mf, const std::string& name) -{ - symbol_table::install_built_in_function (name, octave_value (mf)); -} - -void install_builtin_function (octave_builtin::fcn f, const std::string& name, const std::string& doc, bool is_text_fcn, bool /* can_hide_function -- not yet implemented */)
--- a/src/defun.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/defun.h Wed Feb 20 04:22:50 2008 -0500 @@ -70,54 +70,6 @@ #define DEFCONSTFUN(name, args_name, nargout_name, doc) \ DEFCONSTFUN_INTERNAL (name, args_name, nargout_name, true, doc) -// Define a mapper function. -// -// name is the name of the function, unquoqted. -// -// ch_map is a pointer to a function that should be called for -// integer arguments that are expected to create integer results. -// (It's a kluge to handle character mappers like isalpha.) -// -// d_b_map is a pointer to a function that should be called for real -// arguments that are expected to create bool results. -// -// c_b_map is a pointer to a function that should be called for -// complex arguments that are expected to create bool results. -// -// d_d_map is a pointer to a function that should be called for real -// arguments that are expected to create real results. -// -// c_d_map is a pointer to a function that should be called for -// complex arguments that are expected to create real results. -// -// c_c_map is a pointer to a function that should be called for -// complex arguments that are expected to create complex results. -// -// lo is the lower bound of the range for which real arguments -// return real results (e.g., lo == 0 for sqrt). -// -// hi is the upper bound of the range for which real arguments -// return real results (e.g., hi == Inf for sqrt). -// -// ch_map_flag has the following meanings for the ch_map function: -// -// 0 => this function returns a matrix of ones and zeros -// 1 => this function returns a numeric matrix (any values) -// 2 => this function returns a std::string array -// -// can_ret_cmplx_for_real is a flag that says whether this function -// can create a complex number given a real-valued argument -// (e.g., sqrt (-1)). -// -// doc is the simple help text for the function. - -#define DEFUN_MAPPER(name, ch_map, d_b_map, c_b_map, d_d_map, \ - c_d_map, c_c_map, lo, hi, ch_map_flag, \ - can_ret_cmplx_for_real, doc) \ - DEFUN_MAPPER_INTERNAL (name, ch_map, d_b_map, c_b_map, d_d_map, \ - c_d_map, c_c_map, lo, hi, ch_map_flag, \ - can_ret_cmplx_for_real, doc) - // Make alias another name for the existing function name. This macro // must be used in the same file where name is defined, after the // definition for name.
--- a/src/mappers.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/mappers.cc Wed Feb 20 04:22:50 2008 -0500 @@ -34,148 +34,9 @@ #include "defun.h" #include "error.h" -#include "ov-mapper.h" #include "variables.h" -// FIXME -- perhaps this could be avoided by determining -// whether the is* functions are actually functions or just macros. - -static int -xabs (int c) -{ - return static_cast<unsigned char> (c); -} - -static int -xisalnum (int c) -{ - return isalnum (c); -} - -static int -xisalpha (int c) -{ - return isalpha (c); -} - -static int -xisascii (int c) -{ - return isascii (c); -} - -static int -xiscntrl (int c) -{ - return iscntrl (c); -} - -static int -xisdigit (int c) -{ - return isdigit (c); -} - -static int -xisgraph (int c) -{ - return isgraph (c); -} - -static int -xislower (int c) -{ - return islower (c); -} - -static int -xisprint (int c) -{ - return isprint (c); -} - -static int -xispunct (int c) -{ - return ispunct (c); -} - -static int -xisspace (int c) -{ - return isspace (c); -} - -static int -xisupper (int c) -{ - return isupper (c); -} - -static int -xisxdigit (int c) -{ - return isxdigit (c); -} - -static int -xtoascii (int c) -{ - return toascii (c); -} - -static int -xtolower (int c) -{ - return tolower (c); -} - -static int -xtoupper (int c) -{ - return toupper (c); -} - -static double -xabs (const Complex& x) -{ - return (xisinf (x.real ()) || xisinf (x.imag ())) ? octave_Inf : abs (x); -} - -static Complex -xconj (const Complex& x) -{ - return conj (x); -} - -static double -xconj (double x) -{ - return x; -} - -static double -ximag (const Complex& x) -{ - return x.imag (); -} - -static double -xreal (const Complex& x) -{ - return x.real (); -} - -static int -dummyp (int) -{ - return 0; -} - -void -install_mapper_functions (void) -{ - DEFUN_MAPPER (abs, xabs, 0, 0, fabs, xabs, 0, 0.0, 0.0, 1, 0, +DEFUN (abs, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} abs (@var{z})\n\ Compute the magnitude of @var{z}, defined as\n\ @@ -196,27 +57,64 @@ @result{} 5\n\ @end group\n\ @end example\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).abs (); + else + print_usage (); - DEFUN_MAPPER (acos, 0, 0, 0, acos, 0, acos, -1.0, 1.0, 0, 1, + return retval; +} + +DEFUN (acos, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} acos (@var{x})\n\ Compute the inverse cosine of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).acos (); + else + print_usage (); - DEFUN_MAPPER (acosh, 0, 0, 0, acosh, 0, acosh, 1.0, octave_Inf, 0, 1, + return retval; +} + + +DEFUN (acosh, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} acosh (@var{x})\n\ Compute the inverse hyperbolic cosine of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).acosh (); + else + print_usage (); - DEFUN_MAPPER (angle, 0, 0, 0, arg, std::arg, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (angle, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} angle (@var{z})\n\ See arg.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).arg (); + else + print_usage (); - DEFUN_MAPPER (arg, 0, 0, 0, arg, std::arg, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (arg, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} arg (@var{z})\n\ @deftypefnx {Mapping Function} {} angle (@var{z})\n\ @@ -240,13 +138,31 @@ @result{} 0.92730\n\ @end group\n\ @end example\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).arg (); + else + print_usage (); - DEFUN_MAPPER (asin, 0, 0, 0, asin, 0, asin, -1.0, 1.0, 0, 1, + return retval; +} + +DEFUN (asin, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} asin (@var{x})\n\ Compute the inverse sine of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).asin (); + else + print_usage (); + + return retval; +} /* %!test @@ -259,32 +175,68 @@ %!error asin (1, 2); */ - DEFUN_MAPPER (asinh, 0, 0, 0, asinh, 0, asinh, 0.0, 0.0, 0, 0, +DEFUN (asinh, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} asinh (@var{x})\n\ Compute the inverse hyperbolic sine of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).asinh (); + else + print_usage (); - DEFUN_MAPPER (atan, 0, 0, 0, atan, 0, atan, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (atan, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} atan (@var{x})\n\ Compute the inverse tangent of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).atan (); + else + print_usage (); - DEFUN_MAPPER (atanh, 0, 0, 0, atanh, 0, atanh, -1.0, 1.0, 0, 1, + return retval; +} + +DEFUN (atanh, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} atanh (@var{x})\n\ Compute the inverse hyperbolic tangent of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).atanh (); + else + print_usage (); - DEFUN_MAPPER (ceil, 0, 0, 0, ceil, 0, ceil, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (ceil, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} ceil (@var{x})\n\ Return the smallest integer not less than @var{x}. If @var{x} is\n\ complex, return @code{ceil (real (@var{x})) + ceil (imag (@var{x})) * I}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).ceil (); + else + print_usage (); - DEFUN_MAPPER (conj, 0, 0, 0, xconj, 0, xconj, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (conj, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} conj (@var{z})\n\ Return the complex conjugate of @var{z}, defined as\n\ @@ -297,21 +249,48 @@ @code{conj (@var{z})} = @var{x} - @var{i}@var{y}.\n\ @end ifinfo\n\ @seealso{real, imag}\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).conj (); + else + print_usage (); - DEFUN_MAPPER (cos, 0, 0, 0, cos, 0, std::cos, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (cos, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} cos (@var{x})\n\ Compute the cosine of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).cos (); + else + print_usage (); - DEFUN_MAPPER (cosh, 0, 0, 0, cosh, 0, std::cosh, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (cosh, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} cosh (@var{x})\n\ Compute the hyperbolic cosine of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).cosh (); + else + print_usage (); - DEFUN_MAPPER (erf, 0, 0, 0, erf, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (erf, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} erf (@var{z})\n\ Computes the error function,\n\ @@ -333,9 +312,18 @@ @end smallexample\n\ @end ifinfo\n\ @seealso{erfc, erfinv}\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).erf (); + else + print_usage (); - DEFUN_MAPPER (erfc, 0, 0, 0, erfc, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (erfc, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} erfc (@var{z})\n\ Computes the complementary error function,\n\ @@ -348,16 +336,34 @@ @code{1 - erf (@var{z})}.\n\ @end ifinfo\n\ @seealso{erf, erfinv}\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).erfc (); + else + print_usage (); - DEFUN_MAPPER (exp, 0, 0, 0, exp, 0, std::exp, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (exp, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} exp (@var{x})\n\ Compute the exponential of @var{x}. To compute the matrix exponential,\n\ see @ref{Linear Algebra}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).exp (); + else + print_usage (); - DEFUN_MAPPER (finite, dummyp, xfinite, xfinite, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (finite, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} finite (@var{x})\n\ Return 1 for elements of @var{x} that are finite values and zero\n\ @@ -369,23 +375,51 @@ @result{} [ 1, 0, 0, 0 ]\n\ @end group\n\ @end example\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).finite (); + else + print_usage (); - DEFUN_MAPPER (fix, 0, 0, 0, fix, 0, fix, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (fix, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} fix (@var{x})\n\ Truncate @var{x} toward zero. If @var{x} is complex, return\n\ @code{fix (real (@var{x})) + fix (imag (@var{x})) * I}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).fix (); + else + print_usage (); - DEFUN_MAPPER (floor, 0, 0, 0, floor, 0, floor, 0.0, 0.0, 0, 0, + return retval; +} + + +DEFUN (floor, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} floor (@var{x})\n\ Return the largest integer not greater than @var{x}. If @var{x} is\n\ complex, return @code{floor (real (@var{x})) + floor (imag (@var{x})) * I}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).floor (); + else + print_usage (); - DEFUN_MAPPER (gamma, 0, 0, 0, xgamma, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (gamma, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} gamma (@var{z})\n\ Computes the Gamma function,\n\ @@ -407,53 +441,116 @@ @end example\n\ @end ifinfo\n\ @seealso{gammai, lgamma}\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).gamma (); + else + print_usage (); - DEFUN_MAPPER (imag, 0, 0, 0, imag, ximag, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (imag, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} imag (@var{z})\n\ Return the imaginary part of @var{z} as a real number.\n\ @seealso{real, conj}\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).imag (); + else + print_usage (); - DEFUN_MAPPER (isalnum, xisalnum, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (isalnum, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isalnum (@var{s})\n\ Return 1 for characters that are letters or digits (@code{isalpha\n\ (@var{s})} or @code{isdigit (@var{s})} is true).\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isalnum (); + else + print_usage (); - DEFUN_MAPPER (isalpha, xisalpha, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (isalpha, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isalpha (@var{s})\n\ @deftypefnx {Mapping Function} {} isletter (@var{s})\n\ Return true for characters that are letters (@code{isupper (@var{s})}\n\ or @code{islower (@var{s})} is true).\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isalpha (); + else + print_usage (); + + return retval; +} #ifdef isascii #undef isascii #endif - DEFUN_MAPPER (isascii, xisascii, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, +DEFUN (isascii, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isascii (@var{s})\n\ Return 1 for characters that are ASCII (in the range 0 to 127 decimal).\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isascii (); + else + print_usage (); - DEFUN_MAPPER (iscntrl, xiscntrl, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (iscntrl, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} iscntrl (@var{s})\n\ Return 1 for control characters.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).iscntrl (); + else + print_usage (); - DEFUN_MAPPER (isdigit, xisdigit, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (isdigit, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isdigit (@var{s})\n\ Return 1 for characters that are decimal digits.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isdigit (); + else + print_usage (); - DEFUN_MAPPER (isinf, dummyp, xisinf, xisinf, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (isinf, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isinf (@var{x})\n\ Return 1 for elements of @var{x} that are infinite and zero\n\ @@ -465,21 +562,48 @@ @result{} [ 0, 1, 0, 0 ]\n\ @end group\n\ @end example\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isinf (); + else + print_usage (); - DEFUN_MAPPER (isgraph, xisgraph, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (isgraph, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isgraph (@var{s})\n\ Return 1 for printable characters (but not the space character).\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isgraph (); + else + print_usage (); - DEFUN_MAPPER (islower, xislower, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (islower, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} islower (@var{s})\n\ Return 1 for characters that are lower case letters.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).islower (); + else + print_usage (); - DEFUN_MAPPER (isna, dummyp, octave_is_NA, octave_is_NA, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (isna, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isna (@var{x})\n\ Return 1 for elements of @var{x} that are NA (missing) values and zero\n\ @@ -491,9 +615,18 @@ @result{} [ 0, 0, 1, 0 ]\n\ @end group\n\ @end example\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isna (); + else + print_usage (); - DEFUN_MAPPER (isnan, dummyp, xisnan, xisnan, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (isnan, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isnan (@var{x})\n\ Return 1 for elements of @var{x} that are NaN values and zero\n\ @@ -505,79 +638,178 @@ @result{} [ 0, 0, 1, 1 ]\n\ @end group\n\ @end example\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isnan (); + else + print_usage (); - DEFUN_MAPPER (isprint, xisprint, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (isprint, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isprint (@var{s})\n\ Return 1 for printable characters (including the space character).\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isprint (); + else + print_usage (); - DEFUN_MAPPER (ispunct, xispunct, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (ispunct, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} ispunct (@var{s})\n\ Return 1 for punctuation characters.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).ispunct (); + else + print_usage (); - DEFUN_MAPPER (isspace, xisspace, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (isspace, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isspace (@var{s})\n\ Return 1 for whitespace characters (space, formfeed, newline,\n\ carriage return, tab, and vertical tab).\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isspace (); + else + print_usage (); - DEFUN_MAPPER (isupper, xisupper, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (isupper, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isupper (@var{s})\n\ Return 1 for upper case letters.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isupper (); + else + print_usage (); - DEFUN_MAPPER (isxdigit, xisxdigit, 0, 0, 0, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (isxdigit, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} isxdigit (@var{s})\n\ Return 1 for characters that are hexadecimal digits.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).isxdigit (); + else + print_usage (); - DEFUN_MAPPER (lgamma, 0, 0, 0, xlgamma, 0, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (lgamma, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} lgamma (@var{x})\n\ @deftypefnx {Mapping Function} {} gammaln (@var{x})\n\ Return the natural logarithm of the absolute value of the gamma\n\ function of @var{x}.\n\ @seealso{gamma, gammai}\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).lgamma (); + else + print_usage (); - DEFUN_MAPPER (log, 0, 0, 0, log, 0, std::log, 0.0, octave_Inf, 0, 1, + return retval; +} + +DEFUN (log, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} log (@var{x})\n\ Compute the natural logarithm for each element of @var{x}. To compute the\n\ matrix logarithm, see @ref{Linear Algebra}.\n\ @seealso{log2, log10, logspace, exp}\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).log (); + else + print_usage (); - DEFUN_MAPPER (log10, 0, 0, 0, log10, 0, std::log10, 0.0, octave_Inf, 0, 1, + return retval; +} + +DEFUN (log10, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} log10 (@var{x})\n\ Compute the base-10 logarithm for each element of @var{x}.\n\ @seealso{log, log2, logspace, exp}\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).log10 (); + else + print_usage (); - DEFUN_MAPPER (real, 0, 0, 0, real, xreal, 0, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (real, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} real (@var{z})\n\ Return the real part of @var{z}.\n\ @seealso{imag, conj}\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).real (); + else + print_usage (); - DEFUN_MAPPER (round, 0, 0, 0, xround, 0, xround, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (round, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} round (@var{x})\n\ Return the integer nearest to @var{x}. If @var{x} is complex, return\n\ @code{round (real (@var{x})) + round (imag (@var{x})) * I}.\n\ @seealso{rem}\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).round (); + else + print_usage (); - DEFUN_MAPPER (sign, 0, 0, 0, signum, 0, signum, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (sign, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} sign (@var{x})\n\ Compute the @dfn{signum} function, which is defined as\n\ @@ -598,45 +830,99 @@ @end ifinfo\n\ \n\ For complex arguments, @code{sign} returns @code{x ./ abs (@var{x})}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).signum (); + else + print_usage (); - DEFUN_MAPPER (sin, 0, 0, 0, sin, 0, std::sin, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (sin, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} sin (@var{x})\n\ Compute the sine of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).sin (); + else + print_usage (); - DEFUN_MAPPER (sinh, 0, 0, 0, sinh, 0, std::sinh, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (sinh, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} sinh (@var{x})\n\ Compute the hyperbolic sine of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).sinh (); + else + print_usage (); - DEFUN_MAPPER (sqrt, 0, 0, 0, sqrt, 0, std::sqrt, 0.0, octave_Inf, 0, 1, + return retval; +} + +DEFUN (sqrt, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} sqrt (@var{x})\n\ Compute the square root of @var{x}. If @var{x} is negative, a complex\n\ result is returned. To compute the matrix square root, see\n\ @ref{Linear Algebra}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).sqrt (); + else + print_usage (); - DEFUN_MAPPER (tan, 0, 0, 0, tan, 0, std::tan, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (tan, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} tan (@var{z})\n\ Compute tangent of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).tan (); + else + print_usage (); - DEFUN_MAPPER (tanh, 0, 0, 0, tanh, 0, std::tanh, 0.0, 0.0, 0, 0, + return retval; +} + +DEFUN (tanh, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} tanh (@var{x})\n\ Compute hyperbolic tangent of each element of @var{x}.\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).tanh (); + else + print_usage (); + + return retval; +} #ifdef toascii #undef toascii #endif - DEFUN_MAPPER (toascii, xtoascii, 0, 0, 0, 0, 0, 0.0, 0.0, 1, 0, +DEFUN (toascii, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} toascii (@var{s})\n\ Return ASCII representation of @var{s} in a matrix. For example,\n\ @@ -648,9 +934,18 @@ @end group\n\ \n\ @end example\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).toascii (); + else + print_usage (); - DEFUN_MAPPER (tolower, xtolower, 0, 0, 0, 0, 0, 0.0, 0.0, 2, 0, + return retval; +} + +DEFUN (tolower, args, , "-*- texinfo -*-\n\ @deftypefn {Mapping Function} {} tolower (@var{s})\n\ Return a copy of the string @var{s}, with each upper-case character\n\ @@ -661,9 +956,18 @@ tolower (\"MiXeD cAsE 123\")\n\ @result{} \"mixed case 123\"\n\ @end example\n\ -@end deftypefn"); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).tolower (); + else + print_usage (); - DEFUN_MAPPER (toupper, xtoupper, 0, 0, 0, 0, 0, 0.0, 0.0, 2, 0, + return retval; +} + +DEFUN (toupper, args, , "-*- texinfo -*-\n\ @deftypefn {Built-in Function} {} toupper (@var{s})\n\ Return a copy of the string @var{s}, with each lower-case character\n\ @@ -676,14 +980,20 @@ @result{} \"MIXED CASE 123\"\n\ @end group\n\ @end example\n\ -@end deftypefn"); - - DEFALIAS (gammaln, lgamma); +@end deftypefn") +{ + octave_value retval; + if (args.length () == 1) + retval = args(0).toupper (); + else + print_usage (); - DEFALIAS (isfinite, finite); + return retval; +} - // Leave the previous new line, mkgendoc needs it! -} +DEFALIAS (gammaln, lgamma); + +DEFALIAS (isfinite, finite); /* ;;; Local Variables: ***
--- a/src/mkbuiltins Wed Feb 20 01:09:19 2008 -0500 +++ b/src/mkbuiltins Wed Feb 20 04:22:50 2008 -0500 @@ -86,10 +86,6 @@ #define XDEFCONST_INTERNAL(name, defn, doc) -#define XDEFUN_MAPPER_INTERNAL(name, ch_map, d_b_map, c_b_map, d_d_map, \ - d_c_map, c_c_map, lo, hi, \ - ch_map_flag, can_ret_cmplx_for_real, doc) - EOF for file in $DEF_FILES; do @@ -104,8 +100,8 @@ cat << \EOF -static void -install_builtin_functions (void) +void +install_builtins (void) { EOF @@ -117,14 +113,6 @@ cat << \EOF } -extern void install_mapper_functions (void); - -void -install_builtins (void) -{ - install_mapper_functions (); - install_builtin_functions (); -} EOF exit 0
--- a/src/mkgendoc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/mkgendoc Wed Feb 20 04:22:50 2008 -0500 @@ -68,11 +68,6 @@ #define XDEFCONST_INTERNAL(name, defn, doc) \ print_doc_string (#name, doc); -#define XDEFUN_MAPPER_INTERNAL(name, ch_map, d_b_map, c_b_map, d_d_map, \ - d_c_map, c_c_map, lo, hi, \ - ch_map_flag, can_ret_cmplx_for_real, doc) \ - print_doc_string (#name, doc); - static void print_doc_string (const std::string& name, const std::string& doc) {
--- a/src/ov-base.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-base.cc Wed Feb 20 04:22:50 2008 -0500 @@ -377,7 +377,7 @@ else if (d > MAX_LIMIT) \ retval = MAX_LIMIT; \ else \ - retval = static_cast<T> (fix (d)); \ + retval = static_cast<T> (::fix (d)); \ } \ else \ gripe_wrong_type_arg ("octave_base_value::" #F "_value ()", \ @@ -410,7 +410,7 @@ return retval; } - retval = static_cast<int> (fix (d)); + retval = static_cast<int> (::fix (d)); } else gripe_wrong_type_arg ("octave_base_value::nint_value ()", type_name ()); @@ -895,6 +895,402 @@ return octave_value(); } +octave_value +octave_base_value::abs (void) const +{ + gripe_wrong_type_arg ("octave_base_value::abs ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::acos (void) const +{ + gripe_wrong_type_arg ("octave_base_value::acos ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::acosh (void) const +{ + gripe_wrong_type_arg ("octave_base_value::acosh ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::angle (void) const +{ + gripe_wrong_type_arg ("octave_base_value::angle ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::arg (void) const +{ + gripe_wrong_type_arg ("octave_base_value::arg ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::asin (void) const +{ + gripe_wrong_type_arg ("octave_base_value::asin ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::asinh (void) const +{ + gripe_wrong_type_arg ("octave_base_value::asinh ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::atan (void) const +{ + gripe_wrong_type_arg ("octave_base_value::atan ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::atanh (void) const +{ + gripe_wrong_type_arg ("octave_base_value::atanh ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::ceil (void) const +{ + gripe_wrong_type_arg ("octave_base_value::ceil ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::conj (void) const +{ + gripe_wrong_type_arg ("octave_base_value::conj ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::cos (void) const +{ + gripe_wrong_type_arg ("octave_base_value::cos ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::cosh (void) const +{ + gripe_wrong_type_arg ("octave_base_value::cosh ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::erf (void) const +{ + gripe_wrong_type_arg ("octave_base_value::erf ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::erfc (void) const +{ + gripe_wrong_type_arg ("octave_base_value::erfc ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::exp (void) const +{ + gripe_wrong_type_arg ("octave_base_value::exp ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::finite (void) const +{ + gripe_wrong_type_arg ("octave_base_value::finite ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::fix (void) const +{ + gripe_wrong_type_arg ("octave_base_value::fix ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::floor (void) const +{ + gripe_wrong_type_arg ("octave_base_value::floor ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::gamma (void) const +{ + gripe_wrong_type_arg ("octave_base_value::gamma ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::imag (void) const +{ + gripe_wrong_type_arg ("octave_base_value::imag ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::isinf (void) const +{ + gripe_wrong_type_arg ("octave_base_value::isinf ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::isna (void) const +{ + gripe_wrong_type_arg ("octave_base_value::isna ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::isnan (void) const +{ + gripe_wrong_type_arg ("octave_base_value::isnan ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::lgamma (void) const +{ + gripe_wrong_type_arg ("octave_base_value::lgamma ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::log (void) const +{ + gripe_wrong_type_arg ("octave_base_value::log ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::log10 (void) const +{ + gripe_wrong_type_arg ("octave_base_value::log10 ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::real (void) const +{ + gripe_wrong_type_arg ("octave_base_value::real ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::round (void) const +{ + gripe_wrong_type_arg ("octave_base_value::round ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::signum (void) const +{ + gripe_wrong_type_arg ("octave_base_value::signum ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::sin (void) const +{ + gripe_wrong_type_arg ("octave_base_value::sin ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::sinh (void) const +{ + gripe_wrong_type_arg ("octave_base_value::sinh ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::sqrt (void) const +{ + gripe_wrong_type_arg ("octave_base_value::sqrt ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::tan (void) const +{ + gripe_wrong_type_arg ("octave_base_value::tan ()", type_name ()); + return octave_value (); +} + +octave_value +octave_base_value::tanh (void) const +{ + gripe_wrong_type_arg ("octave_base_value::tanh ()", type_name ()); + return octave_value (); +} + +// String mapper functions, convert to a string +octave_value +octave_base_value::isalnum (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.isalnum (); + else + return octave_value (); +} + +octave_value +octave_base_value::isalpha (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.isalpha (); + else + return octave_value (); +} + +octave_value +octave_base_value::isascii (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.isascii (); + else + return octave_value (); +} + +octave_value +octave_base_value::iscntrl (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.iscntrl (); + else + return octave_value (); +} + +octave_value +octave_base_value::isdigit (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.isdigit (); + else + return octave_value (); +} + +octave_value +octave_base_value::isgraph (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.isgraph (); + else + return octave_value (); +} + +octave_value +octave_base_value::islower (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.islower (); + else + return octave_value (); +} + +octave_value +octave_base_value::isprint (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.isprint (); + else + return octave_value (); +} + +octave_value +octave_base_value::ispunct (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.ispunct (); + else + return octave_value (); +} + +octave_value +octave_base_value::isspace (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.isspace (); + else + return octave_value (); +} + +octave_value +octave_base_value::isupper (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.isupper (); + else + return octave_value (); +} + +octave_value +octave_base_value::isxdigit (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.isxdigit (); + else + return octave_value (); +} + +octave_value +octave_base_value::toascii (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.toascii (); + else + return octave_value (); +} + +octave_value +octave_base_value::tolower (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.tolower (); + else + return octave_value (); +} + +octave_value +octave_base_value::toupper (void) const +{ + octave_value tmp = octave_value (char_array_value (true), true); + if (! error_state) + return tmp.toupper (); + else + return octave_value (); +} + void octave_base_value::lock (void) {
--- a/src/ov-base.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-base.h Wed Feb 20 04:22:50 2008 -0500 @@ -468,6 +468,57 @@ virtual bool islocked (void) const { return false; } + virtual octave_value abs (void) const; + virtual octave_value acos (void) const; + virtual octave_value acosh (void) const; + virtual octave_value angle (void) const; + virtual octave_value arg (void) const; + virtual octave_value asin (void) const; + virtual octave_value asinh (void) const; + virtual octave_value atan (void) const; + virtual octave_value atanh (void) const; + virtual octave_value ceil (void) const; + virtual octave_value conj (void) const; + virtual octave_value cos (void) const; + virtual octave_value cosh (void) const; + virtual octave_value erf (void) const; + virtual octave_value erfc (void) const; + virtual octave_value exp (void) const; + virtual octave_value finite (void) const; + virtual octave_value fix (void) const; + virtual octave_value floor (void) const; + virtual octave_value gamma (void) const; + virtual octave_value imag (void) const; + virtual octave_value isinf (void) const; + virtual octave_value isna (void) const; + virtual octave_value isnan (void) const; + virtual octave_value lgamma (void) const; + virtual octave_value log (void) const; + virtual octave_value log10 (void) const; + virtual octave_value real (void) const; + virtual octave_value round (void) const; + virtual octave_value signum (void) const; + virtual octave_value sin (void) const; + virtual octave_value sinh (void) const; + virtual octave_value sqrt (void) const; + virtual octave_value tan (void) const; + virtual octave_value tanh (void) const; + virtual octave_value isalnum (void) const; + virtual octave_value isalpha (void) const; + virtual octave_value isascii (void) const; + virtual octave_value iscntrl (void) const; + virtual octave_value isdigit (void) const; + virtual octave_value isgraph (void) const; + virtual octave_value islower (void) const; + virtual octave_value isprint (void) const; + virtual octave_value ispunct (void) const; + virtual octave_value isspace (void) const; + virtual octave_value isupper (void) const; + virtual octave_value isxdigit (void) const; + virtual octave_value toascii (void) const; + virtual octave_value tolower (void) const; + virtual octave_value toupper (void) const; + protected: // This should only be called for derived types.
--- a/src/ov-bool-mat.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-bool-mat.h Wed Feb 20 04:22:50 2008 -0500 @@ -36,6 +36,7 @@ #include "oct-stream.h" #include "ov-base.h" #include "ov-base-mat.h" +#include "ov-re-mat.h" #include "ov-typeinfo.h" #include "MatrixType.h" @@ -64,9 +65,6 @@ octave_bool_matrix (const boolMatrix& bm, const MatrixType& t) : octave_base_matrix<boolNDArray> (bm, t) { } - octave_bool_matrix (const Array2<bool>& a) - : octave_base_matrix<boolNDArray> (a) { } - octave_bool_matrix (const octave_bool_matrix& bm) : octave_base_matrix<boolNDArray> (bm) { } @@ -186,6 +184,52 @@ mxArray *as_mxArray (void) const; + // Mapper functions are converted to double for treatment +#define BOOL_MAT_MAPPER(MAP) \ + octave_value MAP (void) const \ + { \ + octave_matrix m (array_value ()); \ + return m.MAP (); \ + } + + BOOL_MAT_MAPPER (abs) + BOOL_MAT_MAPPER (acos) + BOOL_MAT_MAPPER (acosh) + BOOL_MAT_MAPPER (angle) + BOOL_MAT_MAPPER (arg) + BOOL_MAT_MAPPER (asin) + BOOL_MAT_MAPPER (asinh) + BOOL_MAT_MAPPER (atan) + BOOL_MAT_MAPPER (atanh) + BOOL_MAT_MAPPER (ceil) + BOOL_MAT_MAPPER (conj) + BOOL_MAT_MAPPER (cos) + BOOL_MAT_MAPPER (cosh) + BOOL_MAT_MAPPER (erf) + BOOL_MAT_MAPPER (erfc) + BOOL_MAT_MAPPER (exp) + BOOL_MAT_MAPPER (finite) + BOOL_MAT_MAPPER (fix) + BOOL_MAT_MAPPER (floor) + BOOL_MAT_MAPPER (gamma) + BOOL_MAT_MAPPER (imag) + BOOL_MAT_MAPPER (isinf) + BOOL_MAT_MAPPER (isna) + BOOL_MAT_MAPPER (isnan) + BOOL_MAT_MAPPER (lgamma) + BOOL_MAT_MAPPER (log) + BOOL_MAT_MAPPER (log10) + BOOL_MAT_MAPPER (real) + BOOL_MAT_MAPPER (round) + BOOL_MAT_MAPPER (signum) + BOOL_MAT_MAPPER (sin) + BOOL_MAT_MAPPER (sinh) + BOOL_MAT_MAPPER (sqrt) + BOOL_MAT_MAPPER (tan) + BOOL_MAT_MAPPER (tanh) + +#undef BOOL_MAT_MAPPER + protected: DECLARE_OCTAVE_ALLOCATOR
--- a/src/ov-bool-sparse.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-bool-sparse.cc Wed Feb 20 04:22:50 2008 -0500 @@ -171,6 +171,20 @@ return NDArray (Matrix(matrix.matrix_value ())); } +charNDArray +octave_sparse_bool_matrix::char_array_value (bool) const +{ + charNDArray retval (dims (), 0); + octave_idx_type nc = matrix.cols (); + octave_idx_type nr = matrix.rows (); + + for (octave_idx_type j = 0; j < nc; j++) + for (octave_idx_type i = matrix.cidx(j); i < matrix.cidx(j+1); i++) + retval(matrix.ridx(i) + nr * j) = static_cast<char>(matrix.data (i)); + + return retval; +} + boolMatrix octave_sparse_bool_matrix::bool_matrix_value (bool) const {
--- a/src/ov-bool-sparse.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-bool-sparse.h Wed Feb 20 04:22:50 2008 -0500 @@ -112,6 +112,8 @@ ComplexNDArray complex_array_value (bool = false) const; + charNDArray char_array_value (bool = false) const; + boolMatrix bool_matrix_value (bool = false) const; boolNDArray bool_array_value (bool = false) const; @@ -138,6 +140,52 @@ mxArray *as_mxArray (void) const; + // Mapper functions are converted to double for treatment +#define BOOL_SPARSE_MAPPER(MAP) \ + octave_value MAP (void) const \ + { \ + octave_sparse_matrix m (sparse_matrix_value ()); \ + return m.MAP (); \ + } + + BOOL_SPARSE_MAPPER (abs) + BOOL_SPARSE_MAPPER (acos) + BOOL_SPARSE_MAPPER (acosh) + BOOL_SPARSE_MAPPER (angle) + BOOL_SPARSE_MAPPER (arg) + BOOL_SPARSE_MAPPER (asin) + BOOL_SPARSE_MAPPER (asinh) + BOOL_SPARSE_MAPPER (atan) + BOOL_SPARSE_MAPPER (atanh) + BOOL_SPARSE_MAPPER (ceil) + BOOL_SPARSE_MAPPER (conj) + BOOL_SPARSE_MAPPER (cos) + BOOL_SPARSE_MAPPER (cosh) + BOOL_SPARSE_MAPPER (erf) + BOOL_SPARSE_MAPPER (erfc) + BOOL_SPARSE_MAPPER (exp) + BOOL_SPARSE_MAPPER (finite) + BOOL_SPARSE_MAPPER (fix) + BOOL_SPARSE_MAPPER (floor) + BOOL_SPARSE_MAPPER (gamma) + BOOL_SPARSE_MAPPER (imag) + BOOL_SPARSE_MAPPER (isinf) + BOOL_SPARSE_MAPPER (isna) + BOOL_SPARSE_MAPPER (isnan) + BOOL_SPARSE_MAPPER (lgamma) + BOOL_SPARSE_MAPPER (log) + BOOL_SPARSE_MAPPER (log10) + BOOL_SPARSE_MAPPER (real) + BOOL_SPARSE_MAPPER (round) + BOOL_SPARSE_MAPPER (signum) + BOOL_SPARSE_MAPPER (sin) + BOOL_SPARSE_MAPPER (sinh) + BOOL_SPARSE_MAPPER (sqrt) + BOOL_SPARSE_MAPPER (tan) + BOOL_SPARSE_MAPPER (tanh) + +#undef BOOL_SPARSE_MAPPER + protected: DECLARE_OCTAVE_ALLOCATOR
--- a/src/ov-bool.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-bool.h Wed Feb 20 04:22:50 2008 -0500 @@ -37,6 +37,7 @@ #include "oct-stream.h" #include "ov-base.h" #include "ov-base-scalar.h" +#include "ov-scalar.h" #include "ov-typeinfo.h" class Octave_map; @@ -191,6 +192,52 @@ mxArray *as_mxArray (void) const; + // Mapper functions are converted to double for treatment +#define BOOL_MAPPER(MAP) \ + octave_value MAP (void) const \ + { \ + octave_scalar s (static_cast<double> (scalar)); \ + return s.MAP (); \ + } + + BOOL_MAPPER (abs) + BOOL_MAPPER (acos) + BOOL_MAPPER (acosh) + BOOL_MAPPER (angle) + BOOL_MAPPER (arg) + BOOL_MAPPER (asin) + BOOL_MAPPER (asinh) + BOOL_MAPPER (atan) + BOOL_MAPPER (atanh) + BOOL_MAPPER (ceil) + BOOL_MAPPER (conj) + BOOL_MAPPER (cos) + BOOL_MAPPER (cosh) + BOOL_MAPPER (erf) + BOOL_MAPPER (erfc) + BOOL_MAPPER (exp) + BOOL_MAPPER (finite) + BOOL_MAPPER (fix) + BOOL_MAPPER (floor) + BOOL_MAPPER (gamma) + BOOL_MAPPER (imag) + BOOL_MAPPER (isinf) + BOOL_MAPPER (isna) + BOOL_MAPPER (isnan) + BOOL_MAPPER (lgamma) + BOOL_MAPPER (log) + BOOL_MAPPER (log10) + BOOL_MAPPER (real) + BOOL_MAPPER (round) + BOOL_MAPPER (signum) + BOOL_MAPPER (sin) + BOOL_MAPPER (sinh) + BOOL_MAPPER (sqrt) + BOOL_MAPPER (tan) + BOOL_MAPPER (tanh) + +#undef BOOL_MAPPER + private: DECLARE_OCTAVE_ALLOCATOR
--- a/src/ov-cell.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-cell.cc Wed Feb 20 04:22:50 2008 -0500 @@ -829,7 +829,7 @@ for (octave_idx_type i = 0; i < nel; i++) { std::ostringstream buf; - int digits = static_cast<int> (floor (log10 (static_cast<double> (nel)) + 1.0)); + int digits = static_cast<int> (::floor (::log10 (static_cast<double> (nel)) + 1.0)); buf << "_" << std::setw (digits) << std::setfill ('0') << i; std::string s = buf.str ();
--- a/src/ov-complex.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-complex.cc Wed Feb 20 04:22:50 2008 -0500 @@ -28,6 +28,8 @@ #include <iostream> #include "lo-ieee.h" +#include "lo-specfun.h" +#include "lo-mappers.h" #include "oct-obj.h" #include "oct-stream.h" @@ -59,7 +61,7 @@ double im = std::imag (scalar); if (im == 0.0 && ! lo_ieee_signbit (im)) - retval = new octave_scalar (real (scalar)); + retval = new octave_scalar (std::real (scalar)); return retval; } @@ -325,12 +327,69 @@ double *pr = static_cast<double *> (retval->get_data ()); double *pi = static_cast<double *> (retval->get_imag_data ()); - pr[0] = real (scalar); - pi[0] = imag (scalar); + pr[0] = std::real (scalar); + pi[0] = std::imag (scalar); return retval; } +static double +xabs (const Complex& x) +{ + return (xisinf (x.real ()) || xisinf (x.imag ())) ? octave_Inf : abs (x); +} + +static double +ximag (const Complex& x) +{ + return x.imag (); +} + +static double +xreal (const Complex& x) +{ + return x.real (); +} + +#define COMPLEX_MAPPER(MAP, FCN) \ + octave_value \ + octave_complex::MAP (void) const \ + { \ + return octave_value (FCN (scalar)); \ + } + +COMPLEX_MAPPER (abs, xabs) +COMPLEX_MAPPER (acos, ::acos) +COMPLEX_MAPPER (acosh, ::acosh) +COMPLEX_MAPPER (angle, std::arg) +COMPLEX_MAPPER (arg, std::arg) +COMPLEX_MAPPER (asin, ::asin) +COMPLEX_MAPPER (asinh, ::asinh) +COMPLEX_MAPPER (atan, ::atan) +COMPLEX_MAPPER (atanh, ::atanh) +COMPLEX_MAPPER (ceil, ::ceil) +COMPLEX_MAPPER (conj, std::conj) +COMPLEX_MAPPER (cos, std::cos) +COMPLEX_MAPPER (cosh, std::cosh) +COMPLEX_MAPPER (exp, std::exp) +COMPLEX_MAPPER (fix, ::fix) +COMPLEX_MAPPER (floor, ::floor) +COMPLEX_MAPPER (imag, ximag) +COMPLEX_MAPPER (log, std::log) +COMPLEX_MAPPER (log10, std::log10) +COMPLEX_MAPPER (real, xreal) +COMPLEX_MAPPER (round, xround) +COMPLEX_MAPPER (signum, ::signum) +COMPLEX_MAPPER (sin, std::sin) +COMPLEX_MAPPER (sinh, std::sinh) +COMPLEX_MAPPER (sqrt, std::sqrt) +COMPLEX_MAPPER (tan, std::tan) +COMPLEX_MAPPER (tanh, std::tanh) +COMPLEX_MAPPER (finite, xfinite) +COMPLEX_MAPPER (isinf, xisinf) +COMPLEX_MAPPER (isna, octave_is_NA) +COMPLEX_MAPPER (isnan, xisnan) + /* ;;; Local Variables: *** ;;; mode: C++ ***
--- a/src/ov-complex.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-complex.h Wed Feb 20 04:22:50 2008 -0500 @@ -148,6 +148,38 @@ mxArray *as_mxArray (void) const; + octave_value abs (void) const; + octave_value acos (void) const; + octave_value acosh (void) const; + octave_value angle (void) const; + octave_value arg (void) const; + octave_value asin (void) const; + octave_value asinh (void) const; + octave_value atan (void) const; + octave_value atanh (void) const; + octave_value ceil (void) const; + octave_value conj (void) const; + octave_value cos (void) const; + octave_value cosh (void) const; + octave_value exp (void) const; + octave_value fix (void) const; + octave_value floor (void) const; + octave_value imag (void) const; + octave_value log (void) const; + octave_value log10 (void) const; + octave_value real (void) const; + octave_value round (void) const; + octave_value signum (void) const; + octave_value sin (void) const; + octave_value sinh (void) const; + octave_value sqrt (void) const; + octave_value tan (void) const; + octave_value tanh (void) const; + octave_value finite (void) const; + octave_value isinf (void) const; + octave_value isna (void) const; + octave_value isnan (void) const; + private: DECLARE_OCTAVE_ALLOCATOR
--- a/src/ov-cx-mat.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-cx-mat.cc Wed Feb 20 04:22:50 2008 -0500 @@ -30,6 +30,8 @@ #include "data-conv.h" #include "lo-ieee.h" +#include "lo-specfun.h" +#include "lo-mappers.h" #include "mx-base.h" #include "mach-info.h" @@ -180,6 +182,26 @@ return matrix.matrix_value (); } +charNDArray +octave_complex_matrix::char_array_value (bool frc_str_conv) const +{ + charNDArray retval; + + if (! frc_str_conv) + gripe_implicit_conversion ("Octave:num-to-str", + "complex matrix", "string"); + else + { + retval = charNDArray (dims ()); + octave_idx_type nel = numel (); + + for (octave_idx_type i = 0; i < nel; i++) + retval.elem (i) = static_cast<char>(std::real (matrix.elem (i))); + } + + return retval; +} + SparseMatrix octave_complex_matrix::sparse_matrix_value (bool force_conversion) const { @@ -623,13 +645,71 @@ for (mwIndex i = 0; i < nel; i++) { - pr[i] = real (p[i]); - pi[i] = imag (p[i]); + pr[i] = std::real (p[i]); + pi[i] = std::imag (p[i]); } return retval; } +static double +xabs (const Complex& x) +{ + return (xisinf (x.real ()) || xisinf (x.imag ())) ? octave_Inf : abs (x); +} + +static double +ximag (const Complex& x) +{ + return x.imag (); +} + +static double +xreal (const Complex& x) +{ + return x.real (); +} + +#define ARRAY_MAPPER(MAP, AMAP, FCN) \ + octave_value \ + octave_complex_matrix::MAP (void) const \ + { \ + static AMAP cmap = FCN; \ + return matrix.map (cmap); \ + } + +ARRAY_MAPPER (abs, ComplexNDArray::dmapper, xabs) +ARRAY_MAPPER (acos, ComplexNDArray::cmapper, ::acos) +ARRAY_MAPPER (acosh, ComplexNDArray::cmapper, ::acosh) +ARRAY_MAPPER (angle, ComplexNDArray::dmapper, std::arg) +ARRAY_MAPPER (arg, ComplexNDArray::dmapper, std::arg) +ARRAY_MAPPER (asin, ComplexNDArray::cmapper, ::asin) +ARRAY_MAPPER (asinh, ComplexNDArray::cmapper, ::asinh) +ARRAY_MAPPER (atan, ComplexNDArray::cmapper, ::atan) +ARRAY_MAPPER (atanh, ComplexNDArray::cmapper, ::atanh) +ARRAY_MAPPER (ceil, ComplexNDArray::cmapper, ::ceil) +ARRAY_MAPPER (conj, ComplexNDArray::cmapper, std::conj) +ARRAY_MAPPER (cos, ComplexNDArray::cmapper, std::cos) +ARRAY_MAPPER (cosh, ComplexNDArray::cmapper, std::cosh) +ARRAY_MAPPER (exp, ComplexNDArray::cmapper, std::exp) +ARRAY_MAPPER (fix, ComplexNDArray::cmapper, ::fix) +ARRAY_MAPPER (floor, ComplexNDArray::cmapper, ::floor) +ARRAY_MAPPER (imag, ComplexNDArray::dmapper, ximag) +ARRAY_MAPPER (log, ComplexNDArray::cmapper, std::log) +ARRAY_MAPPER (log10, ComplexNDArray::cmapper, std::log10) +ARRAY_MAPPER (real, ComplexNDArray::dmapper, xreal) +ARRAY_MAPPER (round, ComplexNDArray::cmapper, xround) +ARRAY_MAPPER (signum, ComplexNDArray::cmapper, ::signum) +ARRAY_MAPPER (sin, ComplexNDArray::cmapper, std::sin) +ARRAY_MAPPER (sinh, ComplexNDArray::cmapper, std::sinh) +ARRAY_MAPPER (sqrt, ComplexNDArray::cmapper, std::sqrt) +ARRAY_MAPPER (tan, ComplexNDArray::cmapper, std::tan) +ARRAY_MAPPER (tanh, ComplexNDArray::cmapper, std::tanh) +ARRAY_MAPPER (finite, ComplexNDArray::bmapper, xfinite) +ARRAY_MAPPER (isinf, ComplexNDArray::bmapper, xisinf) +ARRAY_MAPPER (isna, ComplexNDArray::bmapper, octave_is_NA) +ARRAY_MAPPER (isnan, ComplexNDArray::bmapper, xisnan) + /* ;;; Local Variables: *** ;;; mode: C++ ***
--- a/src/ov-cx-mat.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-cx-mat.h Wed Feb 20 04:22:50 2008 -0500 @@ -113,6 +113,8 @@ ComplexNDArray complex_array_value (bool = false) const { return matrix; } + charNDArray char_array_value (bool frc_str_conv = false) const; + SparseMatrix sparse_matrix_value (bool = false) const; SparseComplexMatrix sparse_complex_matrix_value (bool = false) const; @@ -149,6 +151,38 @@ mxArray *as_mxArray (void) const; + octave_value abs (void) const; + octave_value acos (void) const; + octave_value acosh (void) const; + octave_value angle (void) const; + octave_value arg (void) const; + octave_value asin (void) const; + octave_value asinh (void) const; + octave_value atan (void) const; + octave_value atanh (void) const; + octave_value ceil (void) const; + octave_value conj (void) const; + octave_value cos (void) const; + octave_value cosh (void) const; + octave_value exp (void) const; + octave_value fix (void) const; + octave_value floor (void) const; + octave_value imag (void) const; + octave_value log (void) const; + octave_value log10 (void) const; + octave_value real (void) const; + octave_value round (void) const; + octave_value signum (void) const; + octave_value sin (void) const; + octave_value sinh (void) const; + octave_value sqrt (void) const; + octave_value tan (void) const; + octave_value tanh (void) const; + octave_value finite (void) const; + octave_value isinf (void) const; + octave_value isna (void) const; + octave_value isnan (void) const; + private: DECLARE_OCTAVE_ALLOCATOR
--- a/src/ov-cx-sparse.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-cx-sparse.cc Wed Feb 20 04:22:50 2008 -0500 @@ -30,6 +30,9 @@ #include <iostream> #include <vector> +#include "lo-specfun.h" +#include "lo-mappers.h" + #include "ov-base.h" #include "ov-scalar.h" #include "ov-complex.h" @@ -69,7 +72,7 @@ Complex c = tmp (0, 0); - if (imag (c) == 0.0) + if (std::imag (c) == 0.0) retval = new octave_scalar (std::real (c)); else retval = new octave_complex (c); @@ -195,6 +198,29 @@ return ComplexNDArray (matrix.matrix_value ()); } +charNDArray +octave_sparse_complex_matrix::char_array_value (bool frc_str_conv) const +{ + charNDArray retval; + + if (! frc_str_conv) + gripe_implicit_conversion ("Octave:num-to-str", + "sparse complex matrix", "string"); + else + { + retval = charNDArray (dims (), 0); + octave_idx_type nc = matrix.cols (); + octave_idx_type nr = matrix.rows (); + + for (octave_idx_type j = 0; j < nc; j++) + for (octave_idx_type i = matrix.cidx(j); i < matrix.cidx(j+1); i++) + retval(matrix.ridx(i) + nr * j) = + static_cast<char>(std::real (matrix.data (i))); + } + + return retval; +} + SparseMatrix octave_sparse_complex_matrix::sparse_matrix_value (bool force_conversion) const { @@ -784,8 +810,8 @@ for (mwIndex i = 0; i < nz; i++) { Complex val = matrix.data(i); - pr[i] = real (val); - pi[i] = imag (val); + pr[i] = std::real (val); + pi[i] = std::imag (val); ir[i] = matrix.ridx(i); } @@ -795,6 +821,64 @@ return retval; } +static double +xabs (const Complex& x) +{ + return (xisinf (x.real ()) || xisinf (x.imag ())) ? octave_Inf : abs (x); +} + +static double +ximag (const Complex& x) +{ + return x.imag (); +} + +static double +xreal (const Complex& x) +{ + return x.real (); +} + +#define SPARSE_MAPPER(MAP, AMAP, FCN) \ + octave_value \ + octave_sparse_complex_matrix::MAP (void) const \ + { \ + static AMAP cmap = FCN; \ + return matrix.map (cmap); \ + } + +SPARSE_MAPPER (abs, SparseComplexMatrix::dmapper, xabs) +SPARSE_MAPPER (acos, SparseComplexMatrix::cmapper, ::acos) +SPARSE_MAPPER (acosh, SparseComplexMatrix::cmapper, ::acosh) +SPARSE_MAPPER (angle, SparseComplexMatrix::dmapper, std::arg) +SPARSE_MAPPER (arg, SparseComplexMatrix::dmapper, std::arg) +SPARSE_MAPPER (asin, SparseComplexMatrix::cmapper, ::asin) +SPARSE_MAPPER (asinh, SparseComplexMatrix::cmapper, ::asinh) +SPARSE_MAPPER (atan, SparseComplexMatrix::cmapper, ::atan) +SPARSE_MAPPER (atanh, SparseComplexMatrix::cmapper, ::atanh) +SPARSE_MAPPER (ceil, SparseComplexMatrix::cmapper, ::ceil) +SPARSE_MAPPER (conj, SparseComplexMatrix::cmapper, std::conj) +SPARSE_MAPPER (cos, SparseComplexMatrix::cmapper, std::cos) +SPARSE_MAPPER (cosh, SparseComplexMatrix::cmapper, std::cosh) +SPARSE_MAPPER (exp, SparseComplexMatrix::cmapper, std::exp) +SPARSE_MAPPER (fix, SparseComplexMatrix::cmapper, ::fix) +SPARSE_MAPPER (floor, SparseComplexMatrix::cmapper, ::floor) +SPARSE_MAPPER (imag, SparseComplexMatrix::dmapper, ximag) +SPARSE_MAPPER (log, SparseComplexMatrix::cmapper, std::log) +SPARSE_MAPPER (log10, SparseComplexMatrix::cmapper, std::log10) +SPARSE_MAPPER (real, SparseComplexMatrix::dmapper, xreal) +SPARSE_MAPPER (round, SparseComplexMatrix::cmapper, xround) +SPARSE_MAPPER (signum, SparseComplexMatrix::cmapper, ::signum) +SPARSE_MAPPER (sin, SparseComplexMatrix::cmapper, std::sin) +SPARSE_MAPPER (sinh, SparseComplexMatrix::cmapper, std::sinh) +SPARSE_MAPPER (sqrt, SparseComplexMatrix::cmapper, std::sqrt) +SPARSE_MAPPER (tan, SparseComplexMatrix::cmapper, std::tan) +SPARSE_MAPPER (tanh, SparseComplexMatrix::cmapper, std::tanh) +SPARSE_MAPPER (finite, SparseComplexMatrix::bmapper, xfinite) +SPARSE_MAPPER (isinf, SparseComplexMatrix::bmapper, xisinf) +SPARSE_MAPPER (isna, SparseComplexMatrix::bmapper, octave_is_NA) +SPARSE_MAPPER (isnan, SparseComplexMatrix::bmapper, xisnan) + /* ;;; Local Variables: *** ;;; mode: C++ ***
--- a/src/ov-cx-sparse.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-cx-sparse.h Wed Feb 20 04:22:50 2008 -0500 @@ -42,7 +42,6 @@ #include "CSparse.h" #include "ov-base-sparse.h" #include "ov-re-sparse.h" -#include "ov-bool-sparse.h" class Octave_map; class octave_value_list; @@ -120,6 +119,8 @@ ComplexNDArray complex_array_value (bool = false) const; + charNDArray char_array_value (bool frc_str_conv = false) const; + SparseMatrix sparse_matrix_value (bool = false) const; SparseComplexMatrix sparse_complex_matrix_value (bool = false) const @@ -149,6 +150,38 @@ mxArray *as_mxArray (void) const; + octave_value abs (void) const; + octave_value acos (void) const; + octave_value acosh (void) const; + octave_value angle (void) const; + octave_value arg (void) const; + octave_value asin (void) const; + octave_value asinh (void) const; + octave_value atan (void) const; + octave_value atanh (void) const; + octave_value ceil (void) const; + octave_value conj (void) const; + octave_value cos (void) const; + octave_value cosh (void) const; + octave_value exp (void) const; + octave_value fix (void) const; + octave_value floor (void) const; + octave_value imag (void) const; + octave_value log (void) const; + octave_value log10 (void) const; + octave_value real (void) const; + octave_value round (void) const; + octave_value signum (void) const; + octave_value sin (void) const; + octave_value sinh (void) const; + octave_value sqrt (void) const; + octave_value tan (void) const; + octave_value tanh (void) const; + octave_value finite (void) const; + octave_value isinf (void) const; + octave_value isna (void) const; + octave_value isnan (void) const; + private: DECLARE_OCTAVE_ALLOCATOR
--- a/src/ov-intx.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-intx.h Wed Feb 20 04:22:50 2008 -0500 @@ -37,6 +37,9 @@ #include "ov-typeinfo.h" #include "gripes.h" +#include "ov-re-mat.h" +#include "ov-scalar.h" + class OCTINTERP_API OCTAVE_VALUE_INT_MATRIX_T @@ -226,6 +229,42 @@ return retval; } +#define MAT_MAPPER(FCN) \ + octave_value FCN (void) const { return matrix.FCN (); } + + MAT_MAPPER (abs) + MAT_MAPPER (signum) + +#undef MAT_MAPPER + + octave_value imag (void) const + { + return OCTAVE_INT_NDARRAY_T (matrix.dims (), + static_cast<OCTAVE_INT_T>(0)); + } + +#define NO_OP_MAPPER(FCN) \ + octave_value FCN (void) const { return octave_value (matrix); } + + NO_OP_MAPPER (ceil) + NO_OP_MAPPER (conj) + NO_OP_MAPPER (fix) + NO_OP_MAPPER (floor) + NO_OP_MAPPER (real) + NO_OP_MAPPER (round) + +#undef NO_OP_MAPPER + +#define BOOL_MAPPER(FCN, VAL) \ + octave_value FCN (void) const { return boolNDArray (matrix.dims (), VAL); } + + BOOL_MAPPER (finite, true) + BOOL_MAPPER (isinf, false) + BOOL_MAPPER (isna, false) + BOOL_MAPPER (isnan, false) + +#undef BOOL_MAPPER + private: DECLARE_OCTAVE_ALLOCATOR @@ -448,6 +487,37 @@ return retval; } +#define SCALAR_MAPPER(FCN) \ + octave_value FCN (void) const { return scalar.FCN (); } + + SCALAR_MAPPER (abs) + SCALAR_MAPPER (signum) + +#undef SCALAR_MAPPER + + octave_value imag (void) const { return static_cast<OCTAVE_INT_T>(0); } + +#define NO_OP_MAPPER(FCN) \ + octave_value FCN (void) const { return octave_value (scalar); } + + NO_OP_MAPPER (ceil) + NO_OP_MAPPER (conj) + NO_OP_MAPPER (fix) + NO_OP_MAPPER (floor) + NO_OP_MAPPER (real) + NO_OP_MAPPER (round) + +#undef NO_OP_MAPPER + +#define BOOL_MAPPER(FCN, VAL) octave_value FCN (void) const { return VAL; } + + BOOL_MAPPER (finite, true) + BOOL_MAPPER (isinf, false) + BOOL_MAPPER (isna, false) + BOOL_MAPPER (isnan, false) + +#undef BOOL_MAPPER + private: DECLARE_OCTAVE_ALLOCATOR
--- a/src/ov-mapper.cc Wed Feb 20 01:09:19 2008 -0500 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,489 +0,0 @@ -/* - -Copyright (C) 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, - 2006, 2007, 2008 John W. Eaton - -This file is part of Octave. - -Octave 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 3 of the License, or (at your -option) any later version. - -Octave 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 Octave; see the file COPYING. If not, see -<http://www.gnu.org/licenses/>. - -*/ - -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif - -#include "quit.h" - -#include "error.h" -#include "gripes.h" -#include "oct-obj.h" -#include "ov-mapper.h" -#include "ov.h" -#include "toplev.h" -#include "unwind-prot.h" - -DEFINE_OCTAVE_ALLOCATOR (octave_mapper); - -DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_mapper, - "built-in mapper function", - "built-in mapper function"); - -static bool -any_element_less_than (const NDArray& a, double val) -{ - octave_idx_type len = a.length (); - - for (octave_idx_type i = 0; i < len; i++) - { - OCTAVE_QUIT; - - if (a(i) < val) - return true; - } - - return false; -} - -static bool -any_element_less_than (const SparseMatrix& a, double val) -{ - octave_idx_type len = a.nnz (); - - if (val > 0. && len != a.numel ()) - return true; - - for (octave_idx_type i = 0; i < len; i++) - { - OCTAVE_QUIT; - - if (a.data(i) < val) - return true; - } - - return false; -} - -static bool -any_element_greater_than (const NDArray& a, double val) -{ - octave_idx_type len = a.length (); - - for (octave_idx_type i = 0; i < len; i++) - { - OCTAVE_QUIT; - - if (a(i) > val) - return true; - } - - return false; -} - -static bool -any_element_greater_than (const SparseMatrix& a, double val) -{ - octave_idx_type len = a.nnz (); - - if (val < 0. && len != a.numel ()) - return true; - - for (octave_idx_type i = 0; i < len; i++) - { - OCTAVE_QUIT; - - if (a.data(i) > val) - return true; - } - - return false; -} - -// In most cases, we could use the map member function from the NDArray -// classes, but as currently implemented, they don't allow us to -// detect errors and abort properly. So use these macros to do the -// looping here instead. - -#define MAPPER_LOOP_2(T, F, M, CONV, R) \ - do \ - { \ - octave_idx_type len = M.length (); \ - \ - T result (M.dims ()); \ - \ - for (octave_idx_type i = 0; i < len; i++) \ - { \ - OCTAVE_QUIT; \ - \ - result(i) = CONV (F (M(i))); \ - \ - if (error_state) \ - return retval; \ - } \ - \ - retval = R; \ - } \ - while (0) - -#define MAPPER_LOOP_1(T, F, M, CONV) \ - MAPPER_LOOP_2 (T, F, M, CONV, result) - -#define MAPPER_LOOP(T, F, M) \ - MAPPER_LOOP_1 (T, F, M, ) - -#define SPARSE_MAPPER_LOOP_2(T, ET, F, M, CONV, R) \ - do \ - { \ - ET f_zero = CONV (F (0.)); \ - \ - if (f_zero != 0.) \ - { \ - octave_idx_type nr = M.rows (); \ - octave_idx_type nc = M.cols (); \ - \ - T result (nr, nc, f_zero); \ - \ - for (octave_idx_type j = 0; j < nc; j++) \ - for (octave_idx_type i = M.cidx(j); i < M.cidx (j+1); i++) \ - { \ - OCTAVE_QUIT; \ - /* Use data instead of elem for better performance. */ \ - result.data (M.ridx (i) + j * nr) = CONV (F (M.data(i))); \ - \ - if (error_state) \ - return retval; \ - } \ - \ - result.maybe_compress (true); \ - retval = R; \ - } \ - else \ - { \ - octave_idx_type nz = M.nnz (); \ - octave_idx_type nr = M.rows (); \ - octave_idx_type nc = M.cols (); \ - \ - T result (nr, nc, nz); \ - ET zero = ET (0.); \ - octave_idx_type ii = 0; \ - result.cidx (ii) = 0; \ - \ - for (octave_idx_type j = 0; j < nc; j++) \ - { \ - for (octave_idx_type i = M.cidx(j); i < M.cidx (j+1); i++) \ - { \ - ET val = CONV (F (M.data (i))); \ - if (val != zero) \ - { \ - result.data (ii) = val; \ - result.ridx (ii++) = M.ridx (i); \ - } \ - OCTAVE_QUIT; \ - \ - if (error_state) \ - return retval; \ - } \ - result.cidx (j+1) = ii; \ - } \ - \ - result.maybe_compress (false); \ - retval = R; \ - } \ - } \ - while (0) - -#define SPARSE_MAPPER_LOOP_1(T, ET, F, M, CONV) \ - SPARSE_MAPPER_LOOP_2 (T, ET, F, M, CONV, result) - -#define SPARSE_MAPPER_LOOP(T, ET, F, M) \ - SPARSE_MAPPER_LOOP_1 (T, ET, F, M, ) - -octave_value -octave_mapper::apply (const octave_value& arg) const -{ - octave_value retval; - - // FIXME -- is_real_type can return true. Should it really - // work that way? - - if (arg.is_real_type () - && (c_c_map_fcn || d_d_map_fcn || d_b_map_fcn) - && ! (arg.is_string () && ch_map_fcn)) - { - if (arg.is_scalar_type ()) - { - double d = arg.double_value (); - - if (can_ret_cmplx_for_real && (d < lower_limit || d > upper_limit)) - { - if (c_c_map_fcn) - retval = c_c_map_fcn (Complex (d)); - else - error ("%s: unable to handle real arguments", - name().c_str ()); - } - else if (d_d_map_fcn) - retval = d_d_map_fcn (d); - else if (d_b_map_fcn) - retval = d_b_map_fcn (d); - else - error ("%s: unable to handle real arguments", - name().c_str ()); - } - else if (arg.is_sparse_type ()) - { - const SparseMatrix m = arg.sparse_matrix_value (); - - if (error_state) - return retval; - - if (can_ret_cmplx_for_real - && (any_element_less_than (m, lower_limit) - || any_element_greater_than (m, upper_limit))) - { - if (c_c_map_fcn) - SPARSE_MAPPER_LOOP (SparseComplexMatrix, Complex, - c_c_map_fcn, m); - else - error ("%s: unable to handle real arguments", - name().c_str ()); - } - else if (d_d_map_fcn) - SPARSE_MAPPER_LOOP (SparseMatrix, double, d_d_map_fcn, m); - else if (d_b_map_fcn) - SPARSE_MAPPER_LOOP (SparseBoolMatrix, bool, d_b_map_fcn, m); - else - error ("%s: unable to handle real arguments", - name().c_str ()); - } - else - { - NDArray m = arg.array_value (); - - if (error_state) - return retval; - - if (can_ret_cmplx_for_real - && (any_element_less_than (m, lower_limit) - || any_element_greater_than (m, upper_limit))) - { - if (c_c_map_fcn) - MAPPER_LOOP (ComplexNDArray, c_c_map_fcn, m); - else - error ("%s: unable to handle real arguments", - name().c_str ()); - } - else if (d_d_map_fcn) - MAPPER_LOOP (NDArray, d_d_map_fcn, m); - else if (d_b_map_fcn) - MAPPER_LOOP (boolNDArray, d_b_map_fcn, m); - else - error ("%s: unable to handle real arguments", - name().c_str ()); - } - } - else if (arg.is_complex_type ()) - { - // In the following, we use d_d_map_fcn to handle the case of - // imag (z) == 0. This can happen when a complex value is not - // narrowed to a real value automatically, possibly due to some - // imaginary parts being -0. - - if (arg.is_scalar_type ()) - { - Complex c = arg.complex_value (); - - if (c_d_map_fcn) - retval = c_d_map_fcn (c); - else if (c_c_map_fcn) - retval = c_c_map_fcn (c); - else if (c_b_map_fcn) - retval = c_b_map_fcn (c); - else if (d_d_map_fcn && imag (c) == 0) - retval = d_d_map_fcn (real (c)); - else - error ("%s: unable to handle complex arguments", - name().c_str ()); - } - else if (arg.is_sparse_type ()) - { - SparseComplexMatrix cm = arg.sparse_complex_matrix_value (); - - if (error_state) - return retval; - - if (c_d_map_fcn) - SPARSE_MAPPER_LOOP (SparseMatrix, double, c_d_map_fcn, cm); - else if (c_c_map_fcn) - SPARSE_MAPPER_LOOP (SparseComplexMatrix, Complex, - c_c_map_fcn, cm); - else if (c_b_map_fcn) - SPARSE_MAPPER_LOOP (SparseBoolMatrix, bool, - c_b_map_fcn, cm); - else - { - SparseMatrix im = imag (cm); - - if (d_d_map_fcn && im.all_elements_are_zero ()) - SPARSE_MAPPER_LOOP (SparseMatrix, double, d_d_map_fcn, real (cm)); - else - error ("%s: unable to handle complex arguments", - name().c_str ()); - } - } - else - { - ComplexNDArray cm = arg.complex_array_value (); - - if (error_state) - return retval; - - if (c_d_map_fcn) - MAPPER_LOOP (NDArray, c_d_map_fcn, cm); - else if (c_c_map_fcn) - MAPPER_LOOP (ComplexNDArray, c_c_map_fcn, cm); - else if (c_b_map_fcn) - MAPPER_LOOP (boolNDArray, c_b_map_fcn, cm); - else - { - NDArray im = imag (cm); - - if (d_d_map_fcn && im.all_elements_are_zero ()) - MAPPER_LOOP (NDArray, d_d_map_fcn, real (cm)); - else - error ("%s: unable to handle complex arguments", - name().c_str ()); - } - } - } - else if (ch_map_fcn) - { - // FIXME -- this could be done in a better way... - - octave_value tmp = arg.convert_to_str (); - - if (! error_state) - { - charNDArray chm = tmp.char_array_value (); - - if (! error_state) - { - switch (ch_map_flag) - { - case 0: - MAPPER_LOOP_1 (boolNDArray, ch_map_fcn, chm, bool); - break; - - case 1: - MAPPER_LOOP (NDArray, ch_map_fcn, chm); - break; - - case 2: - MAPPER_LOOP_2 (charNDArray, ch_map_fcn, chm, , - octave_value (result, true)); - break; - - default: - panic_impossible (); - break; - } - } - } - } - else - gripe_wrong_type_arg ("mapper", arg); - - return retval; -} - -octave_value_list -octave_mapper::subsref (const std::string& type, - const std::list<octave_value_list>& idx, - int nargout) -{ - octave_value_list retval; - - switch (type[0]) - { - case '(': - { - int tmp_nargout = (type.length () > 1 && nargout == 0) ? 1 : nargout; - - retval = do_multi_index_op (tmp_nargout, idx.front ()); - } - break; - - case '{': - case '.': - { - std::string nm = type_name (); - error ("%s cannot be indexed with %c", nm.c_str (), type[0]); - } - break; - - default: - panic_impossible (); - } - - // FIXME -- perhaps there should be an - // octave_value_list::next_subsref member function? See also - // and octave_builtin::subsref. - - if (idx.size () > 1) - retval = retval(0).next_subsref (nargout, type, idx); - - return retval; -} - -octave_value_list -octave_mapper::do_multi_index_op (int, const octave_value_list& args) -{ - octave_value retval; - - if (error_state) - return retval; - - int nargin = args.length (); - - if (nargin > 1) - ::error ("%s: too many arguments", name().c_str ()); - else if (nargin < 1) - ::error ("%s: too few arguments", name().c_str ()); - else - { - if (args(0).is_defined ()) - { - unwind_protect::begin_frame ("mapper_func_eval"); - - octave_call_stack::push (this); - - unwind_protect::add (octave_call_stack::unwind_pop, 0); - - retval = apply (args(0)); - - unwind_protect::run_frame ("mapper_func_eval"); - } - else - ::error ("%s: argument undefined", name().c_str ()); - } - - return retval; -} - -/* -;;; Local Variables: *** -;;; mode: C++ *** -;;; End: *** -*/
--- a/src/ov-mapper.h Wed Feb 20 01:09:19 2008 -0500 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,134 +0,0 @@ -/* - -Copyright (C) 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, - 2007 John W. Eaton - -This file is part of Octave. - -Octave 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 3 of the License, or (at your -option) any later version. - -Octave 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 Octave; see the file COPYING. If not, see -<http://www.gnu.org/licenses/>. - -*/ - -#if !defined (octave_mapper_h) -#define octave_mapper_h 1 - -#include <string> - -#include "oct-obj.h" -#include "ov-fcn.h" -#include "ov-typeinfo.h" - -class octave_value; -class octave_value_list; - -// Builtin mapper functions. - -class -octave_mapper : public octave_function -{ -public: - - octave_mapper (void) { } - - typedef int (*ch_mapper) (int); - typedef bool (*d_b_mapper) (double); - typedef bool (*c_b_mapper) (const Complex&); - typedef double (*d_d_mapper) (double); - typedef double (*c_d_mapper) (const Complex&); - typedef Complex (*c_c_mapper) (const Complex&); - - octave_mapper (ch_mapper ch, d_b_mapper db, c_b_mapper cb, - d_d_mapper dd, c_d_mapper dc, - c_c_mapper cc, double ll, double ul, - int cmf, bool crcfr, - const std::string& nm = std::string (), - const std::string& ds = std::string ()) - : octave_function (nm, ds), ch_map_fcn (ch), - d_b_map_fcn (db), c_b_map_fcn (cb), - d_d_map_fcn (dd), c_d_map_fcn (dc), c_c_map_fcn (cc), - lower_limit (ll), upper_limit (ul), ch_map_flag (cmf), - can_ret_cmplx_for_real (crcfr) { } - - ~octave_mapper (void) { } - - octave_function *function_value (bool = false) { return this; } - - octave_value subsref (const std::string&, - const std::list<octave_value_list>&) - { - panic_impossible (); - return octave_value (); - } - - octave_value_list subsref (const std::string& type, - const std::list<octave_value_list>& idx, - int nargout); - - octave_value_list - do_multi_index_op (int nargout, const octave_value_list& args); - -private: - - octave_value apply (const octave_value& arg) const; - - // ch_map_fcn is a kluge. - - ch_mapper ch_map_fcn; - d_b_mapper d_b_map_fcn; - c_b_mapper c_b_map_fcn; - d_d_mapper d_d_map_fcn; - c_d_mapper c_d_map_fcn; - c_c_mapper c_c_map_fcn; - - // If flag is nonzero and we are not calling ch_map_fcn, lower_limit - // and upper_limit specify the range of values for which a real arg - // returns a real value. Outside that range, we have to convert args - // to complex, and call the complex valued function. - - double lower_limit; - double upper_limit; - - // ch_map_flag has the following meanings: - // - // 0 => this function returns a matrix of ones and zeros - // 1 => this function returns a numeric matrix (any values) - // 2 => this function returns a std::string array - - int ch_map_flag; - - // can_ret_cmplx_for_real is a flag that says whether this function - // can create a complex number given a real-valued argument - // (e.g., sqrt (-1)). - - bool can_ret_cmplx_for_real; - - // No copying! - - octave_mapper (const octave_mapper& om); - - octave_mapper& operator = (const octave_mapper& om); - - DECLARE_OCTAVE_ALLOCATOR - - DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA -}; - -#endif - -/* -;;; Local Variables: *** -;;; mode: C++ *** -;;; End: *** -*/
--- a/src/ov-range.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-range.h Wed Feb 20 04:22:50 2008 -0500 @@ -262,6 +262,50 @@ mxArray *as_mxArray (void) const; + // Mapper functions are converted to double for treatment +#define RANGE_MAPPER(MAP) \ + octave_value MAP (void) const \ + { \ + octave_matrix m (array_value ()); \ + return m.MAP (); \ + } + + RANGE_MAPPER (abs) + RANGE_MAPPER (acos) + RANGE_MAPPER (acosh) + RANGE_MAPPER (angle) + RANGE_MAPPER (arg) + RANGE_MAPPER (asin) + RANGE_MAPPER (asinh) + RANGE_MAPPER (atan) + RANGE_MAPPER (atanh) + RANGE_MAPPER (ceil) + RANGE_MAPPER (conj) + RANGE_MAPPER (cos) + RANGE_MAPPER (cosh) + RANGE_MAPPER (erf) + RANGE_MAPPER (erfc) + RANGE_MAPPER (exp) + RANGE_MAPPER (finite) + RANGE_MAPPER (fix) + RANGE_MAPPER (floor) + RANGE_MAPPER (gamma) + RANGE_MAPPER (imag) + RANGE_MAPPER (isinf) + RANGE_MAPPER (isna) + RANGE_MAPPER (isnan) + RANGE_MAPPER (lgamma) + RANGE_MAPPER (log) + RANGE_MAPPER (log10) + RANGE_MAPPER (real) + RANGE_MAPPER (round) + RANGE_MAPPER (signum) + RANGE_MAPPER (sin) + RANGE_MAPPER (sinh) + RANGE_MAPPER (sqrt) + RANGE_MAPPER (tan) + RANGE_MAPPER (tanh) + private: Range range;
--- a/src/ov-re-mat.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-re-mat.cc Wed Feb 20 04:22:50 2008 -0500 @@ -33,6 +33,8 @@ #include "data-conv.h" #include "lo-ieee.h" #include "lo-utils.h" +#include "lo-specfun.h" +#include "lo-mappers.h" #include "mach-info.h" #include "mx-base.h" #include "quit.h" @@ -648,6 +650,104 @@ return retval; } +static bool +any_element_less_than (const NDArray& a, double val) +{ + octave_idx_type len = a.length (); + const double *m = a.fortran_vec (); + + for (octave_idx_type i = 0; i < len; i++) + { + OCTAVE_QUIT; + + if (m[i] < val) + return true; + } + + return false; +} + +static bool +any_element_greater_than (const NDArray& a, double val) +{ + octave_idx_type len = a.length (); + const double *m = a.fortran_vec (); + + for (octave_idx_type i = 0; i < len; i++) + { + OCTAVE_QUIT; + + if (m[i] > val) + return true; + } + + return false; +} + +#define ARRAY_MAPPER(MAP, AMAP, FCN) \ + octave_value \ + octave_matrix::MAP (void) const \ + { \ + static AMAP dmap = FCN; \ + return matrix.map (dmap); \ + } + +#define CD_ARRAY_MAPPER(MAP, RFCN, CFCN, L1, L2) \ + octave_value \ + octave_matrix::MAP (void) const \ + { \ + static NDArray::dmapper dmap = RFCN; \ + static NDArray::cmapper cmap = CFCN; \ + \ + return (any_element_less_than (matrix, L1) \ + ? octave_value (matrix.map (cmap)) \ + : (any_element_greater_than (matrix, L2) \ + ? octave_value (matrix.map (cmap)) \ + : octave_value (matrix.map (dmap)))); \ + } + +static double +xconj (double x) +{ + return x; +} + +ARRAY_MAPPER (erf, NDArray::dmapper, ::erf) +ARRAY_MAPPER (erfc, NDArray::dmapper, ::erfc) +ARRAY_MAPPER (gamma, NDArray::dmapper, xgamma) +ARRAY_MAPPER (lgamma, NDArray::dmapper, xlgamma) +ARRAY_MAPPER (abs, NDArray::dmapper, ::fabs) +ARRAY_MAPPER (acos, NDArray::dmapper, ::acos) +CD_ARRAY_MAPPER (acosh, ::acosh, ::acosh, 1.0, octave_Inf) +ARRAY_MAPPER (angle, NDArray::dmapper, ::arg) +ARRAY_MAPPER (arg, NDArray::dmapper, ::arg) +CD_ARRAY_MAPPER (asin, ::asin, ::asin, -1.0, 1.0) +ARRAY_MAPPER (asinh, NDArray::dmapper,::asinh) +ARRAY_MAPPER (atan, NDArray::dmapper, ::atan) +CD_ARRAY_MAPPER (atanh, ::atanh, ::atanh, -1.0, 1.0) +ARRAY_MAPPER (ceil, NDArray::dmapper, ::ceil) +ARRAY_MAPPER (conj, NDArray::dmapper, xconj) +ARRAY_MAPPER (cos, NDArray::dmapper, ::cos) +ARRAY_MAPPER (cosh, NDArray::dmapper, ::cosh) +ARRAY_MAPPER (exp, NDArray::dmapper, ::exp) +ARRAY_MAPPER (fix, NDArray::dmapper, ::fix) +ARRAY_MAPPER (floor, NDArray::dmapper, ::floor) +ARRAY_MAPPER (imag, NDArray::dmapper, ::imag) +CD_ARRAY_MAPPER (log, ::log, std::log, 0.0, octave_Inf) +CD_ARRAY_MAPPER (log10, ::log10, std::log10, 0.0, octave_Inf) +ARRAY_MAPPER (real, NDArray::dmapper, ::real) +ARRAY_MAPPER (round, NDArray::dmapper, xround) +ARRAY_MAPPER (signum, NDArray::dmapper, ::signum) +ARRAY_MAPPER (sin, NDArray::dmapper, ::sin) +ARRAY_MAPPER (sinh, NDArray::dmapper, ::sinh) +CD_ARRAY_MAPPER (sqrt, ::sqrt, std::sqrt, 0.0, octave_Inf) +ARRAY_MAPPER (tan, NDArray::dmapper, ::tan) +ARRAY_MAPPER (tanh, NDArray::dmapper, ::tanh) +ARRAY_MAPPER (finite, NDArray::bmapper, xfinite) +ARRAY_MAPPER (isinf, NDArray::bmapper, xisinf) +ARRAY_MAPPER (isna, NDArray::bmapper, octave_is_NA) +ARRAY_MAPPER (isnan, NDArray::bmapper, xisnan) + DEFUN (double, args, , "-*- texinfo -*-\n\ @deftypefn {Built-in Function} {} double (@var{x})\n\
--- a/src/ov-re-mat.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-re-mat.h Wed Feb 20 04:22:50 2008 -0500 @@ -178,8 +178,43 @@ mxArray *as_mxArray (void) const; + octave_value erf (void) const; + octave_value erfc (void) const; + octave_value gamma (void) const; + octave_value lgamma (void) const; + octave_value abs (void) const; + octave_value acos (void) const; + octave_value acosh (void) const; + octave_value angle (void) const; + octave_value arg (void) const; + octave_value asin (void) const; + octave_value asinh (void) const; + octave_value atan (void) const; + octave_value atanh (void) const; + octave_value ceil (void) const; + octave_value conj (void) const; + octave_value cos (void) const; + octave_value cosh (void) const; + octave_value exp (void) const; + octave_value fix (void) const; + octave_value floor (void) const; + octave_value imag (void) const; + octave_value log (void) const; + octave_value log10 (void) const; + octave_value real (void) const; + octave_value round (void) const; + octave_value signum (void) const; + octave_value sin (void) const; + octave_value sinh (void) const; + octave_value sqrt (void) const; + octave_value tan (void) const; + octave_value tanh (void) const; + octave_value finite (void) const; + octave_value isinf (void) const; + octave_value isna (void) const; + octave_value isnan (void) const; + private: - DECLARE_OCTAVE_ALLOCATOR DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
--- a/src/ov-re-sparse.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-re-sparse.cc Wed Feb 20 04:22:50 2008 -0500 @@ -30,6 +30,9 @@ #include <iostream> #include <vector> +#include "lo-specfun.h" +#include "lo-mappers.h" + #include "ov-base.h" #include "ov-scalar.h" #include "gripes.h" @@ -153,6 +156,20 @@ return boolNDArray (m); } +charNDArray +octave_sparse_matrix::char_array_value (bool) const +{ + charNDArray retval (dims (), 0); + octave_idx_type nc = matrix.cols (); + octave_idx_type nr = matrix.rows (); + + for (octave_idx_type j = 0; j < nc; j++) + for (octave_idx_type i = matrix.cidx(j); i < matrix.cidx(j+1); i++) + retval(matrix.ridx(i) + nr * j) = static_cast<char>(matrix.data (i)); + + return retval; +} + ComplexMatrix octave_sparse_matrix::complex_matrix_value (bool) const { @@ -819,6 +836,108 @@ return retval; } +static bool +any_element_less_than (const SparseMatrix& a, double val) +{ + octave_idx_type len = a.nnz (); + + if (val > 0. && len != a.numel ()) + return true; + + for (octave_idx_type i = 0; i < len; i++) + { + OCTAVE_QUIT; + + if (a.data(i) < val) + return true; + } + + return false; +} + +static bool +any_element_greater_than (const SparseMatrix& a, double val) +{ + octave_idx_type len = a.nnz (); + + if (val < 0. && len != a.numel ()) + return true; + + for (octave_idx_type i = 0; i < len; i++) + { + OCTAVE_QUIT; + + if (a.data(i) > val) + return true; + } + + return false; +} + +#define SPARSE_MAPPER(MAP, AMAP, FCN) \ + octave_value \ + octave_sparse_matrix::MAP (void) const \ + { \ + static AMAP dmap = FCN; \ + return matrix.map (dmap); \ + } + +#define CD_SPARSE_MAPPER(MAP, RFCN, CFCN, L1, L2) \ + octave_value \ + octave_sparse_matrix::MAP (void) const \ + { \ + static NDArray::dmapper dmap = RFCN; \ + static NDArray::cmapper cmap = CFCN; \ + \ + return (any_element_less_than (matrix, L1) \ + ? octave_value (matrix.map (cmap)) \ + : (any_element_greater_than (matrix, L2) \ + ? octave_value (matrix.map (cmap)) \ + : octave_value (matrix.map (dmap)))); \ + } + +static double +xconj (double x) +{ + return x; +} + +SPARSE_MAPPER (erf, SparseMatrix::dmapper, ::erf) +SPARSE_MAPPER (erfc, SparseMatrix::dmapper, ::erfc) +SPARSE_MAPPER (gamma, SparseMatrix::dmapper, xgamma) +SPARSE_MAPPER (lgamma, SparseMatrix::dmapper, xlgamma) +SPARSE_MAPPER (abs, SparseMatrix::dmapper, ::fabs) +SPARSE_MAPPER (acos, SparseMatrix::dmapper, ::acos) +CD_SPARSE_MAPPER (acosh, ::acosh, ::acosh, 1.0, octave_Inf) +SPARSE_MAPPER (angle, SparseMatrix::dmapper, ::arg) +SPARSE_MAPPER (arg, SparseMatrix::dmapper, ::arg) +CD_SPARSE_MAPPER (asin, ::asin, ::asin, -1.0, 1.0) +SPARSE_MAPPER (asinh, SparseMatrix::dmapper, ::asinh) +SPARSE_MAPPER (atan, SparseMatrix::dmapper, ::atan) +CD_SPARSE_MAPPER (atanh, ::atanh, ::atanh, -1.0, 1.0) +SPARSE_MAPPER (ceil, SparseMatrix::dmapper, ::ceil) +SPARSE_MAPPER (conj, SparseMatrix::dmapper, xconj) +SPARSE_MAPPER (cos, SparseMatrix::dmapper, ::cos) +SPARSE_MAPPER (cosh, SparseMatrix::dmapper, ::cosh) +SPARSE_MAPPER (exp, SparseMatrix::dmapper, ::exp) +SPARSE_MAPPER (fix, SparseMatrix::dmapper, ::fix) +SPARSE_MAPPER (floor, SparseMatrix::dmapper, ::floor) +SPARSE_MAPPER (imag, SparseMatrix::dmapper, ::imag) +CD_SPARSE_MAPPER (log, ::log, std::log, 0.0, octave_Inf) +CD_SPARSE_MAPPER (log10, ::log10, std::log10, 0.0, octave_Inf) +SPARSE_MAPPER (real, SparseMatrix::dmapper, ::real) +SPARSE_MAPPER (round, SparseMatrix::dmapper, xround) +SPARSE_MAPPER (signum, SparseMatrix::dmapper, ::signum) +SPARSE_MAPPER (sin, SparseMatrix::dmapper, ::sin) +SPARSE_MAPPER (sinh, SparseMatrix::dmapper, ::sinh) +CD_SPARSE_MAPPER (sqrt, ::sqrt, std::sqrt, 0.0, octave_Inf) +SPARSE_MAPPER (tan, SparseMatrix::dmapper, ::tan) +SPARSE_MAPPER (tanh, SparseMatrix::dmapper, ::tanh) +SPARSE_MAPPER (finite, SparseMatrix::bmapper, xfinite) +SPARSE_MAPPER (isinf, SparseMatrix::bmapper, xisinf) +SPARSE_MAPPER (isna, SparseMatrix::bmapper, octave_is_NA) +SPARSE_MAPPER (isnan, SparseMatrix::bmapper, xisnan) + /* ;;; Local Variables: *** ;;; mode: C++ ***
--- a/src/ov-re-sparse.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-re-sparse.h Wed Feb 20 04:22:50 2008 -0500 @@ -42,7 +42,6 @@ #include "dSparse.h" #include "MatrixType.h" #include "ov-base-sparse.h" -#include "ov-bool-sparse.h" #include "ov-cx-sparse.h" class Octave_map; @@ -114,6 +113,8 @@ boolNDArray bool_array_value (bool warn = false) const; + charNDArray char_array_value (bool = false) const; + ComplexMatrix complex_matrix_value (bool = false) const; ComplexNDArray complex_array_value (bool = false) const; @@ -150,7 +151,44 @@ mxArray *as_mxArray (void) const; + octave_value erf (void) const; + octave_value erfc (void) const; + octave_value gamma (void) const; + octave_value lgamma (void) const; + octave_value abs (void) const; + octave_value acos (void) const; + octave_value acosh (void) const; + octave_value angle (void) const; + octave_value arg (void) const; + octave_value asin (void) const; + octave_value asinh (void) const; + octave_value atan (void) const; + octave_value atanh (void) const; + octave_value ceil (void) const; + octave_value conj (void) const; + octave_value cos (void) const; + octave_value cosh (void) const; + octave_value exp (void) const; + octave_value fix (void) const; + octave_value floor (void) const; + octave_value imag (void) const; + octave_value log (void) const; + octave_value log10 (void) const; + octave_value real (void) const; + octave_value round (void) const; + octave_value signum (void) const; + octave_value sin (void) const; + octave_value sinh (void) const; + octave_value sqrt (void) const; + octave_value tan (void) const; + octave_value tanh (void) const; + octave_value finite (void) const; + octave_value isinf (void) const; + octave_value isna (void) const; + octave_value isnan (void) const; + private: + octave_value map (double (*fcn) (double)) const; DECLARE_OCTAVE_ALLOCATOR
--- a/src/ov-scalar.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-scalar.cc Wed Feb 20 04:22:50 2008 -0500 @@ -29,6 +29,8 @@ #include "data-conv.h" #include "mach-info.h" +#include "lo-specfun.h" +#include "lo-mappers.h" #include "defun.h" #include "gripes.h" @@ -283,6 +285,64 @@ return retval; } +#define SCALAR_MAPPER(MAP, FCN) \ + octave_value \ + octave_scalar::MAP (void) const \ + { \ + return octave_value (FCN (scalar)); \ + } + +#define CD_SCALAR_MAPPER(MAP, RFCN, CFCN, L1, L2) \ + octave_value \ + octave_scalar::MAP (void) const \ + { \ + return (scalar < L1 || scalar > L2 \ + ? octave_value (CFCN (Complex (scalar))) \ + : octave_value (RFCN (scalar))); \ + } + +static double +xconj (double x) +{ + return x; +} + +SCALAR_MAPPER (erf, ::erf) +SCALAR_MAPPER (erfc, ::erfc) +SCALAR_MAPPER (gamma, xgamma) +SCALAR_MAPPER (lgamma, xlgamma) +SCALAR_MAPPER (abs, ::fabs) +SCALAR_MAPPER (acos, ::acos) +CD_SCALAR_MAPPER (acosh, ::acosh, ::acosh, 1.0, octave_Inf) +SCALAR_MAPPER (angle, ::arg) +SCALAR_MAPPER (arg, ::arg) +CD_SCALAR_MAPPER (asin, ::asin, ::asin, -1.0, 1.0) +SCALAR_MAPPER (asinh, ::asinh) +SCALAR_MAPPER (atan, ::atan) +CD_SCALAR_MAPPER (atanh, ::atanh, ::atanh, -1.0, 1.0) +SCALAR_MAPPER (ceil, ::ceil) +SCALAR_MAPPER (conj, xconj) +SCALAR_MAPPER (cos, ::cos) +SCALAR_MAPPER (cosh, ::cosh) +SCALAR_MAPPER (exp, ::exp) +SCALAR_MAPPER (fix, ::fix) +SCALAR_MAPPER (floor, ::floor) +SCALAR_MAPPER (imag, ::imag) +CD_SCALAR_MAPPER (log, ::log, std::log, 0.0, octave_Inf) +CD_SCALAR_MAPPER (log10, ::log10, std::log10, 0.0, octave_Inf) +SCALAR_MAPPER (real, ::real) +SCALAR_MAPPER (round, ::round) +SCALAR_MAPPER (signum, ::signum) +SCALAR_MAPPER (sin, ::sin) +SCALAR_MAPPER (sinh, ::sinh) +CD_SCALAR_MAPPER (sqrt, ::sqrt, std::sqrt, 0.0, octave_Inf) +SCALAR_MAPPER (tan, ::tan) +SCALAR_MAPPER (tanh, ::tanh) +SCALAR_MAPPER (finite, xfinite) +SCALAR_MAPPER (isinf, xisinf) +SCALAR_MAPPER (isna, octave_is_NA) +SCALAR_MAPPER (isnan, xisnan) + /* ;;; Local Variables: *** ;;; mode: C++ ***
--- a/src/ov-scalar.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-scalar.h Wed Feb 20 04:22:50 2008 -0500 @@ -219,7 +219,44 @@ mxArray *as_mxArray (void) const; + octave_value erf (void) const; + octave_value erfc (void) const; + octave_value gamma (void) const; + octave_value lgamma (void) const; + octave_value abs (void) const; + octave_value acos (void) const; + octave_value acosh (void) const; + octave_value angle (void) const; + octave_value arg (void) const; + octave_value asin (void) const; + octave_value asinh (void) const; + octave_value atan (void) const; + octave_value atanh (void) const; + octave_value ceil (void) const; + octave_value conj (void) const; + octave_value cos (void) const; + octave_value cosh (void) const; + octave_value exp (void) const; + octave_value fix (void) const; + octave_value floor (void) const; + octave_value imag (void) const; + octave_value log (void) const; + octave_value log10 (void) const; + octave_value real (void) const; + octave_value round (void) const; + octave_value signum (void) const; + octave_value sin (void) const; + octave_value sinh (void) const; + octave_value sqrt (void) const; + octave_value tan (void) const; + octave_value tanh (void) const; + octave_value finite (void) const; + octave_value isinf (void) const; + octave_value isna (void) const; + octave_value isnan (void) const; + private: + octave_value map (double (*fcn) (double)) const; DECLARE_OCTAVE_ALLOCATOR
--- a/src/ov-str-mat.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-str-mat.cc Wed Feb 20 04:22:50 2008 -0500 @@ -772,6 +772,45 @@ #endif +#define MACRO_WRAPPER(FCN) \ + static int x ## FCN (int c) { return FCN (c); } + +#define STRING_MAPPER(MAP, AMAP, FCN) \ + MACRO_WRAPPER (FCN) \ + octave_value \ + octave_char_matrix_str::MAP (void) const \ + { \ + static charNDArray::mapper smap = x ## FCN; \ + return matrix.AMAP (smap); \ + } + +#define TOSTRING_MAPPER(MAP, AMAP, FCN) \ + MACRO_WRAPPER (FCN) \ + \ + octave_value \ + octave_char_matrix_str::MAP (void) const \ + { \ + static charNDArray::mapper smap = x ## FCN; \ + return (is_sq_string () ? octave_value (matrix.AMAP (smap), true, '\'') : \ + octave_value (matrix.AMAP (smap), true)); \ + } + +STRING_MAPPER (isalnum, bmap, isalnum) +STRING_MAPPER (isalpha, bmap, isalpha) +STRING_MAPPER (isascii, bmap, isascii) +STRING_MAPPER (iscntrl, bmap, iscntrl) +STRING_MAPPER (isdigit, bmap, isdigit) +STRING_MAPPER (isgraph, bmap, isgraph) +STRING_MAPPER (islower, bmap, islower) +STRING_MAPPER (isprint, bmap, isprint) +STRING_MAPPER (ispunct, bmap, ispunct) +STRING_MAPPER (isspace, bmap, isspace) +STRING_MAPPER (isupper, bmap, isupper) +STRING_MAPPER (isxdigit, bmap, isxdigit) +STRING_MAPPER (toascii, dmap, toascii) +TOSTRING_MAPPER (tolower, smap, tolower) +TOSTRING_MAPPER (toupper, smap, toupper) + /* ;;; Local Variables: *** ;;; mode: C++ ***
--- a/src/ov-str-mat.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov-str-mat.h Wed Feb 20 04:22:50 2008 -0500 @@ -35,6 +35,7 @@ #include "error.h" #include "oct-stream.h" #include "ov.h" +#include "ov-re-mat.h" #include "ov-ch-mat.h" #include "ov-typeinfo.h" @@ -127,10 +128,11 @@ std::string string_value (bool force = false) const; octave_value sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const - { return octave_value (matrix.sort (dim, mode), true); } + { return octave_value (matrix.sort (dim, mode), true); } + octave_value sort (Array<octave_idx_type> &sidx, octave_idx_type dim = 0, sortmode mode = ASCENDING) const - { return octave_value (matrix.sort (sidx, dim, mode), true); } + { return octave_value (matrix.sort (sidx, dim, mode), true); } bool print_as_scalar (void) const { return (rows () <= 1); } @@ -156,6 +158,56 @@ oct_mach_info::float_format flt_fmt) const { return os.write (matrix, block_size, output_type, skip, flt_fmt); } + octave_value isalnum (void) const; + octave_value isalpha (void) const; + octave_value isascii (void) const; + octave_value iscntrl (void) const; + octave_value isdigit (void) const; + octave_value isgraph (void) const; + octave_value islower (void) const; + octave_value isprint (void) const; + octave_value ispunct (void) const; + octave_value isspace (void) const; + octave_value isupper (void) const; + octave_value isxdigit (void) const; + octave_value toascii (void) const; + octave_value tolower (void) const; + octave_value toupper (void) const; + +#define MAT_MAPPER(MAP) \ + octave_value MAP (void) const \ + { \ + octave_matrix m (array_value (true)); \ + return m.MAP (); \ + } + + MAT_MAPPER (abs) + MAT_MAPPER (angle) + MAT_MAPPER (arg) + MAT_MAPPER (ceil) + MAT_MAPPER (conj) + MAT_MAPPER (fix) + MAT_MAPPER (floor) + MAT_MAPPER (imag) + MAT_MAPPER (real) + MAT_MAPPER (round) + MAT_MAPPER (signum) + +#undef MAT_MAPPER + +#define BOOL_MAT_MAPPER(MAP, VAL) \ + octave_value MAP (void) const \ + { \ + return boolNDArray (matrix.dims (), VAL); \ + } + + BOOL_MAT_MAPPER (finite, true) + BOOL_MAT_MAPPER (isinf, false) + BOOL_MAT_MAPPER (isna, false) + BOOL_MAT_MAPPER (isnan, false) + +#undef BOOL_MAT_MAPPER + protected: octave_value do_index_op_internal (const octave_value_list& idx, @@ -228,10 +280,11 @@ octave_value sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const - { return octave_value (matrix.sort (dim, mode), true, '\''); } + { return octave_value (matrix.sort (dim, mode), true, '\''); } + octave_value sort (Array<octave_idx_type> &sidx, octave_idx_type dim = 0, sortmode mode = ASCENDING) const - { return octave_value (matrix.sort (sidx, dim, mode), true, '\''); } + { return octave_value (matrix.sort (sidx, dim, mode), true, '\''); } private:
--- a/src/ov.cc Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov.cc Wed Feb 20 04:22:50 2008 -0500 @@ -61,7 +61,6 @@ #include "ov-cs-list.h" #include "ov-colon.h" #include "ov-builtin.h" -#include "ov-mapper.h" #include "ov-dld-fcn.h" #include "ov-usr-fcn.h" #include "ov-fcn-handle.h" @@ -2169,7 +2168,6 @@ octave_cs_list::register_type (); octave_magic_colon::register_type (); octave_builtin::register_type (); - octave_mapper::register_type (); octave_user_function::register_type (); octave_dld_function::register_type (); octave_fcn_handle::register_type ();
--- a/src/ov.h Wed Feb 20 01:09:19 2008 -0500 +++ b/src/ov.h Wed Feb 20 04:22:50 2008 -0500 @@ -877,6 +877,62 @@ bool islocked (void) const { return rep->islocked (); } +#define MAPPER_FORWARD(F) \ + octave_value F (void) const { return rep->F (); } + + MAPPER_FORWARD (abs) + MAPPER_FORWARD (acos) + MAPPER_FORWARD (acosh) + MAPPER_FORWARD (angle) + MAPPER_FORWARD (arg) + MAPPER_FORWARD (asin) + MAPPER_FORWARD (asinh) + MAPPER_FORWARD (atan) + MAPPER_FORWARD (atanh) + MAPPER_FORWARD (ceil) + MAPPER_FORWARD (conj) + MAPPER_FORWARD (cos) + MAPPER_FORWARD (cosh) + MAPPER_FORWARD (erf) + MAPPER_FORWARD (erfc) + MAPPER_FORWARD (exp) + MAPPER_FORWARD (finite) + MAPPER_FORWARD (fix) + MAPPER_FORWARD (floor) + MAPPER_FORWARD (gamma) + MAPPER_FORWARD (imag) + MAPPER_FORWARD (isinf) + MAPPER_FORWARD (isna) + MAPPER_FORWARD (isnan) + MAPPER_FORWARD (lgamma) + MAPPER_FORWARD (log) + MAPPER_FORWARD (log10) + MAPPER_FORWARD (real) + MAPPER_FORWARD (round) + MAPPER_FORWARD (signum) + MAPPER_FORWARD (sin) + MAPPER_FORWARD (sinh) + MAPPER_FORWARD (sqrt) + MAPPER_FORWARD (tan) + MAPPER_FORWARD (tanh) + MAPPER_FORWARD (isalnum) + MAPPER_FORWARD (isalpha) + MAPPER_FORWARD (isascii) + MAPPER_FORWARD (iscntrl) + MAPPER_FORWARD (isdigit) + MAPPER_FORWARD (isgraph) + MAPPER_FORWARD (islower) + MAPPER_FORWARD (isprint) + MAPPER_FORWARD (ispunct) + MAPPER_FORWARD (isspace) + MAPPER_FORWARD (isupper) + MAPPER_FORWARD (isxdigit) + MAPPER_FORWARD (toascii) + MAPPER_FORWARD (tolower) + MAPPER_FORWARD (toupper) + +#undef MAPPER_FORWARD + protected: // The real representation.