Mercurial > octave
view libinterp/corefcn/tril.cc @ 22898:9baa19102908
refactor display and disp functions (bug #49794)
* pr-output.cc (Fdisp, Ffdisp): Tag with dispatch classes.
(Fdisplay): New function.
* ov-class.cc (octave_class::print_with_name):
Simply call octave_base_value::print_with_name.
* ov-classdef.cc (octave_classdef::print): Simply call print_raw.
(octave_classdef::print_with_name):
Simply call octave_base_value::print_with_name.
* variables.cc (bind_ans): Call display function to print result.
* pt-assign.cc (tree_simple_assignment::rvalue1,
tree_multi_assignment::rvalue): Likewise.
* pt-id.cc (tree_identifier::rvalue): Likewise.
* display.m: Delete.
* scripts/general/module.mk: Update.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Fri, 16 Dec 2016 00:10:27 -0500 |
parents | 3a2b891d0b33 |
children | ef4d915df748 |
line wrap: on
line source
/* Copyright (C) 2004-2016 David Bateman Copyright (C) 2009 VZLU Prague 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 (HAVE_CONFIG_H) # include "config.h" #endif #include <algorithm> #include "Array.h" #include "Sparse.h" #include "mx-base.h" #include "ov.h" #include "Cell.h" #include "defun.h" #include "error.h" #include "ovl.h" // The bulk of the work. template <typename T> static Array<T> do_tril (const Array<T>& a, octave_idx_type k, bool pack) { octave_idx_type nr = a.rows (); octave_idx_type nc = a.columns (); const T *avec = a.fortran_vec (); octave_idx_type zero = 0; if (pack) { octave_idx_type j1 = std::min (std::max (zero, k), nc); octave_idx_type j2 = std::min (std::max (zero, nr + k), nc); octave_idx_type n = j1 * nr + ((j2 - j1) * (nr-(j1-k) + nr-(j2-1-k))) / 2; Array<T> r (dim_vector (n, 1)); T *rvec = r.fortran_vec (); for (octave_idx_type j = 0; j < nc; j++) { octave_idx_type ii = std::min (std::max (zero, j - k), nr); rvec = std::copy (avec + ii, avec + nr, rvec); avec += nr; } return r; } else { Array<T> r (a.dims ()); T *rvec = r.fortran_vec (); for (octave_idx_type j = 0; j < nc; j++) { octave_idx_type ii = std::min (std::max (zero, j - k), nr); std::fill (rvec, rvec + ii, T ()); std::copy (avec + ii, avec + nr, rvec + ii); avec += nr; rvec += nr; } return r; } } template <typename T> static Array<T> do_triu (const Array<T>& a, octave_idx_type k, bool pack) { octave_idx_type nr = a.rows (); octave_idx_type nc = a.columns (); const T *avec = a.fortran_vec (); octave_idx_type zero = 0; if (pack) { octave_idx_type j1 = std::min (std::max (zero, k), nc); octave_idx_type j2 = std::min (std::max (zero, nr + k), nc); octave_idx_type n = ((j2 - j1) * ((j1+1-k) + (j2-k))) / 2 + (nc - j2) * nr; Array<T> r (dim_vector (n, 1)); T *rvec = r.fortran_vec (); for (octave_idx_type j = 0; j < nc; j++) { octave_idx_type ii = std::min (std::max (zero, j + 1 - k), nr); rvec = std::copy (avec, avec + ii, rvec); avec += nr; } return r; } else { NoAlias<Array<T> > r (a.dims ()); T *rvec = r.fortran_vec (); for (octave_idx_type j = 0; j < nc; j++) { octave_idx_type ii = std::min (std::max (zero, j + 1 - k), nr); std::copy (avec, avec + ii, rvec); std::fill (rvec + ii, rvec + nr, T ()); avec += nr; rvec += nr; } return r; } } // These two are by David Bateman. // FIXME: optimizations possible. "pack" support missing. template <typename T> static Sparse<T> do_tril (const Sparse<T>& a, octave_idx_type k, bool pack) { if (pack) // FIXME error ("tril: \"pack\" not implemented for sparse matrices"); Sparse<T> m = a; octave_idx_type nc = m.cols (); for (octave_idx_type j = 0; j < nc; j++) for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++) if (m.ridx (i) < j-k) m.data(i) = 0.; m.maybe_compress (true); return m; } template <typename T> static Sparse<T> do_triu (const Sparse<T>& a, octave_idx_type k, bool pack) { if (pack) // FIXME error ("triu: \"pack\" not implemented for sparse matrices"); Sparse<T> m = a; octave_idx_type nc = m.cols (); for (octave_idx_type j = 0; j < nc; j++) for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++) if (m.ridx (i) > j-k) m.data(i) = 0.; m.maybe_compress (true); return m; } // Convenience dispatchers. template <typename T> static Array<T> do_trilu (const Array<T>& a, octave_idx_type k, bool lower, bool pack) { return lower ? do_tril (a, k, pack) : do_triu (a, k, pack); } template <typename T> static Sparse<T> do_trilu (const Sparse<T>& a, octave_idx_type k, bool lower, bool pack) { return lower ? do_tril (a, k, pack) : do_triu (a, k, pack); } static octave_value do_trilu (const std::string& name, const octave_value_list& args) { bool lower = (name == "tril"); int nargin = args.length (); bool pack = false; if (nargin >= 2 && args(nargin-1).is_string ()) { pack = (args(nargin-1).string_value () == "pack"); nargin--; } if (nargin < 1 || nargin > 2) print_usage (); octave_idx_type k = 0; if (nargin == 2) k = args(1).idx_type_value (true); octave_value arg = args(0); dim_vector dims = arg.dims (); if (dims.ndims () != 2) error ("%s: need a 2-D matrix", name.c_str ()); else if (k < -dims(0) || k > dims(1)) error ("%s: requested diagonal out of range", name.c_str ()); octave_value retval; switch (arg.builtin_type ()) { case btyp_double: if (arg.is_sparse_type ()) retval = do_trilu (arg.sparse_matrix_value (), k, lower, pack); else retval = do_trilu (arg.array_value (), k, lower, pack); break; case btyp_complex: if (arg.is_sparse_type ()) retval = do_trilu (arg.sparse_complex_matrix_value (), k, lower, pack); else retval = do_trilu (arg.complex_array_value (), k, lower, pack); break; case btyp_bool: if (arg.is_sparse_type ()) retval = do_trilu (arg.sparse_bool_matrix_value (), k, lower, pack); else retval = do_trilu (arg.bool_array_value (), k, lower, pack); break; #define ARRAYCASE(TYP) \ case btyp_ ## TYP: \ retval = do_trilu (arg.TYP ## _array_value (), k, lower, pack); \ break ARRAYCASE (float); ARRAYCASE (float_complex); ARRAYCASE (int8); ARRAYCASE (int16); ARRAYCASE (int32); ARRAYCASE (int64); ARRAYCASE (uint8); ARRAYCASE (uint16); ARRAYCASE (uint32); ARRAYCASE (uint64); ARRAYCASE (char); #undef ARRAYCASE default: { // Generic code that works on octave-values, that is slow // but will also work on arbitrary user types if (pack) // FIXME error ("%s: \"pack\" not implemented for class %s", name.c_str (), arg.class_name ().c_str ()); octave_value tmp = arg; if (arg.is_empty ()) return arg; octave_idx_type nr = dims(0); octave_idx_type nc = dims(1); // The sole purpose of this code is to force the correct matrix size. // This would not be necessary if the octave_value resize function // allowed a fill_value. It also allows odd attributes in some user // types to be handled. With a fill_value, it should be replaced with // // octave_value_list ov_idx; // tmp = tmp.resize(dim_vector (0,0)).resize (dims, fill_value); octave_value_list ov_idx; std::list<octave_value_list> idx_tmp; ov_idx(1) = static_cast<double> (nc+1); ov_idx(0) = Range (1, nr); idx_tmp.push_back (ov_idx); ov_idx(1) = static_cast<double> (nc); tmp = tmp.resize (dim_vector (0,0)); tmp = tmp.subsasgn ("(",idx_tmp, arg.do_index_op (ov_idx)); tmp = tmp.resize (dims); if (lower) { octave_idx_type st = nc < nr + k ? nc : nr + k; for (octave_idx_type j = 1; j <= st; j++) { octave_idx_type nr_limit = 1 > j - k ? 1 : j - k; ov_idx(1) = static_cast<double> (j); ov_idx(0) = Range (nr_limit, nr); std::list<octave_value_list> idx; idx.push_back (ov_idx); tmp = tmp.subsasgn ("(", idx, arg.do_index_op (ov_idx)); } } else { octave_idx_type st = k + 1 > 1 ? k + 1 : 1; for (octave_idx_type j = st; j <= nc; j++) { octave_idx_type nr_limit = nr < j - k ? nr : j - k; ov_idx(1) = static_cast<double> (j); ov_idx(0) = Range (1, nr_limit); std::list<octave_value_list> idx; idx.push_back (ov_idx); tmp = tmp.subsasgn ("(", idx, arg.do_index_op (ov_idx)); } } retval = tmp; } } return retval; } DEFUN (tril, args, , doc: /* -*- texinfo -*- @deftypefn {} {} tril (@var{A}) @deftypefnx {} {} tril (@var{A}, @var{k}) @deftypefnx {} {} tril (@var{A}, @var{k}, @var{pack}) @deftypefnx {} {} triu (@var{A}) @deftypefnx {} {} triu (@var{A}, @var{k}) @deftypefnx {} {} triu (@var{A}, @var{k}, @var{pack}) Return a new matrix formed by extracting the lower (@code{tril}) or upper (@code{triu}) triangular part of the matrix @var{A}, and setting all other elements to zero. The second argument is optional, and specifies how many diagonals above or below the main diagonal should also be set to zero. The default value of @var{k} is zero, so that @code{triu} and @code{tril} normally include the main diagonal as part of the result. If the value of @var{k} is nonzero integer, the selection of elements starts at an offset of @var{k} diagonals above or below the main diagonal; above for positive @var{k} and below for negative @var{k}. The absolute value of @var{k} must not be greater than the number of subdiagonals or superdiagonals. For example: @example @group tril (ones (3), -1) @result{} 0 0 0 1 0 0 1 1 0 @end group @end example @noindent and @example @group tril (ones (3), 1) @result{} 1 1 0 1 1 1 1 1 1 @end group @end example If the option @qcode{"pack"} is given as third argument, the extracted elements are not inserted into a matrix, but rather stacked column-wise one above other. @seealso{diag} @end deftypefn */) { return do_trilu ("tril", args); } DEFUN (triu, args, , doc: /* -*- texinfo -*- @deftypefn {} {} triu (@var{A}) @deftypefnx {} {} triu (@var{A}, @var{k}) @deftypefnx {} {} triu (@var{A}, @var{k}, @var{pack}) See the documentation for the @code{tril} function (@pxref{tril}). @seealso{tril} @end deftypefn */) { return do_trilu ("triu", args); } /* %!test %! a = [1, 2, 3; 4, 5, 6; 7, 8, 9; 10, 11, 12]; %! %! l0 = [1, 0, 0; 4, 5, 0; 7, 8, 9; 10, 11, 12]; %! l1 = [1, 2, 0; 4, 5, 6; 7, 8, 9; 10, 11, 12]; %! l2 = [1, 2, 3; 4, 5, 6; 7, 8, 9; 10, 11, 12]; %! lm1 = [0, 0, 0; 4, 0, 0; 7, 8, 0; 10, 11, 12]; %! lm2 = [0, 0, 0; 0, 0, 0; 7, 0, 0; 10, 11, 0]; %! lm3 = [0, 0, 0; 0, 0, 0; 0, 0, 0; 10, 0, 0]; %! lm4 = [0, 0, 0; 0, 0, 0; 0, 0, 0; 0, 0, 0]; %! %! assert (tril (a, -4), lm4); %! assert (tril (a, -3), lm3); %! assert (tril (a, -2), lm2); %! assert (tril (a, -1), lm1); %! assert (tril (a), l0); %! assert (tril (a, 1), l1); %! assert (tril (a, 2), l2); %!error tril () */