Mercurial > octave
view liboctave/util/lo-array-errwarn.cc @ 30564:796f54d4ddbf stable
update Octave Project Developers copyright for the new year
In files that have the "Octave Project Developers" copyright notice,
update for 2021.
In all .txi and .texi files except gpl.txi and gpl.texi in the
doc/liboctave and doc/interpreter directories, change the copyright
to "Octave Project Developers", the same as used for other source
files. Update copyright notices for 2022 (not done since 2019). For
gpl.txi and gpl.texi, change the copyright notice to be "Free Software
Foundation, Inc." and leave the date at 2007 only because this file
only contains the text of the GPL, not anything created by the Octave
Project Developers.
Add Paul Thomas to contributors.in.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Tue, 28 Dec 2021 18:22:40 -0500 |
parents | 6d827dcde2b9 |
children | 83f9f8bda883 |
line wrap: on
line source
//////////////////////////////////////////////////////////////////////// // // Copyright (C) 2016-2022 The Octave Project Developers // // See the file COPYRIGHT.md in the top-level directory of this // distribution or <https://octave.org/copyright/>. // // 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 // <https://www.gnu.org/licenses/>. // //////////////////////////////////////////////////////////////////////// #if defined (HAVE_CONFIG_H) # include "config.h" #endif #include <cinttypes> #include <cmath> #include <limits> #include <sstream> #include "lo-array-errwarn.h" #include "lo-error.h" namespace octave { // Text constants used to shorten code below. static const char *error_id_nonconformant_args = "Octave:nonconformant-args"; static const char *error_id_index_out_of_bounds = "Octave:index-out-of-bounds"; static const char *error_id_invalid_index = "Octave:invalid-index"; static const char *warning_id_nearly_singular_matrix = "Octave:nearly-singular-matrix"; static const char *warning_id_singular_matrix = "Octave:singular-matrix"; void err_nan_to_logical_conversion (void) { (*current_liboctave_error_handler) ("invalid conversion from NaN to logical"); } void err_nan_to_character_conversion (void) { (*current_liboctave_error_handler) ("invalid conversion from NaN to character"); } void err_nonconformant (const char *op, octave_idx_type op1_len, octave_idx_type op2_len) { const char *err_id = error_id_nonconformant_args; (*current_liboctave_error_with_id_handler) (err_id, "%s: nonconformant arguments (op1 len: %" OCTAVE_IDX_TYPE_FORMAT ", op2 len: % " OCTAVE_IDX_TYPE_FORMAT ")", op, op1_len, op2_len); } void err_nonconformant (const char *op, octave_idx_type op1_nr, octave_idx_type op1_nc, octave_idx_type op2_nr, octave_idx_type op2_nc) { const char *err_id = error_id_nonconformant_args; (*current_liboctave_error_with_id_handler) (err_id, "%s: nonconformant arguments " "(op1 is %" OCTAVE_IDX_TYPE_FORMAT "x%" OCTAVE_IDX_TYPE_FORMAT ", " "op2 is %" OCTAVE_IDX_TYPE_FORMAT"x%" OCTAVE_IDX_TYPE_FORMAT ")", op, op1_nr, op1_nc, op2_nr, op2_nc); } void err_nonconformant (const char *op, const dim_vector& op1_dims, const dim_vector& op2_dims) { const char *err_id = error_id_nonconformant_args; std::string op1_dims_str = op1_dims.str (); std::string op2_dims_str = op2_dims.str (); (*current_liboctave_error_with_id_handler) (err_id, "%s: nonconformant arguments (op1 is %s, op2 is %s)", op, op1_dims_str.c_str (), op2_dims_str.c_str ()); } void err_del_index_out_of_range (bool is1d, octave_idx_type idx, octave_idx_type ext) { const char *err_id = error_id_index_out_of_bounds; (*current_liboctave_error_with_id_handler) (err_id, "A(%s) = []: index out of bounds: value %" OCTAVE_IDX_TYPE_FORMAT " out of bound %" OCTAVE_IDX_TYPE_FORMAT, is1d ? "I" : "..,I,..", idx, ext); } // Show the expression that caused the error, e.g., "A(-1,_)", // "A(0+1i)", "A(_,3)". Show how many indices come before/after the // offending one, e.g., (<error>), (<error>,_), or (_,<error>,...[x5]...) std::string index_exception::expression (void) const { std::ostringstream buf; if (m_var.empty () || m_var == "<unknown>") buf << "index "; else buf << m_var; bool show_parens = m_dim > 0; if (show_parens) { if (m_dim < 5) { buf << '('; for (octave_idx_type i = 1; i < m_dim; i++) buf << "_,"; } else buf << "(...[x" << m_dim - 1 << "]..."; } buf << m_index; if (show_parens) { if (m_nd - m_dim < 5) { for (octave_idx_type i = 0; i < m_nd - m_dim; i++) buf << ",_"; if (m_nd >= m_dim) buf << ')'; } else buf << "...[x" << m_nd - m_dim << "]...)"; } return buf.str (); } class invalid_index : public index_exception { public: invalid_index (const std::string& value, octave_idx_type ndim, octave_idx_type dimen) : index_exception (value, ndim, dimen) { // Virtual, but the one we want to call is defined in this class. update_message (); } void update_message (void) { static std::string exp = std::to_string (std::numeric_limits<octave_idx_type>::digits); set_message (expression () + ": subscripts must be either integers 1 to (2^" + exp + ")-1 or logicals"); } // ID of error to throw const char * err_id (void) const { return error_id_invalid_index; } }; // Complain if an index is negative, fractional, or too big. void err_invalid_index (const std::string& idx, octave_idx_type nd, octave_idx_type dim, const std::string&) { invalid_index e (idx, nd, dim); throw e; } void err_invalid_index (octave_idx_type n, octave_idx_type nd, octave_idx_type dim, const std::string& var) { err_invalid_index (std::to_string (n + 1), nd, dim, var); } void err_invalid_index (double n, octave_idx_type nd, octave_idx_type dim, const std::string& var) { std::ostringstream buf; buf << n + 1; if (! std::isnan (n)) { // if n not an integer, but would be printed as one, show diff double nearest = std::floor (n + 1.5); if (n + 1 != nearest && (buf.str ().find ('.') == std::string::npos)) buf << std::showpos << (n + 1 - nearest); } err_invalid_index (buf.str (), nd, dim, var); } // Complain for read access beyond the bounds of an array. class out_of_range : public index_exception { public: out_of_range (const std::string& value, octave_idx_type nd, octave_idx_type dim, octave_idx_type ext, const dim_vector& size) : index_exception (value, nd, dim), m_size (size), m_extent (ext) { // Virtual, but the one we want to call is defined in this class. update_message (); } void update_message (void) { set_message (expression () + ": out of bound " + std::to_string (m_extent) + " (dimensions are " + m_size.str ('x') + ")"); } // ID of error to throw. const char * err_id (void) const { return error_id_index_out_of_bounds; } private: // Dimension of object being accessed. dim_vector m_size; // Length of dimension being accessed. octave_idx_type m_extent; }; // Complain of an index that is out of range void err_index_out_of_range (int nd, int dim, octave_idx_type idx, octave_idx_type ext, const dim_vector& dv) { throw out_of_range (std::to_string (idx), nd, dim, ext, dv); } void err_invalid_resize (void) { (*current_liboctave_error_with_id_handler) ("Octave:invalid-resize", "Invalid resizing operation or ambiguous assignment to an out-of-bounds array element"); } void warn_singular_matrix (double rcond) { if (rcond == 0.0) { (*current_liboctave_warning_with_id_handler) (warning_id_singular_matrix, "matrix singular to machine precision"); } else { (*current_liboctave_warning_with_id_handler) (warning_id_nearly_singular_matrix, "matrix singular to machine precision, rcond = %g", rcond); } } // DEPRECATED in Octave 6. // Complain of an index that is out of range, but we don't know matrix size void err_index_out_of_range (int nd, int dim, octave_idx_type idx, octave_idx_type ext) { // The dim_vector setting here doesn't really make sense. However, // this function has been deprecated and will be removed in version // 8, so there's no need to attempt to fix it. throw out_of_range (std::to_string (idx), nd, dim, ext, dim_vector (1, 1, 1, 1, 1, 1, 1)); } } /* Tests in test/index.tst */