Mercurial > octave-antonio
view libinterp/octave-value/ov-range.cc @ 17281:bc924baa2c4e
doc: Add new @qcode macro for code samples which are quoted.
Macro handles options ("on") or properties ("position") more elegantly
than @code{"text"}.
* doc/interpreter/macros.texi: Add new @qcode macro.
* doc/interpreter/tips.txi: Add documentation about @qcode macro.
* doc/interpreter/basics.txi, doc/interpreter/container.txi,
doc/interpreter/emacs.txi, doc/interpreter/errors.txi,
doc/interpreter/eval.txi, doc/interpreter/expr.txi,
doc/interpreter/external.txi, doc/interpreter/func.txi,
doc/interpreter/grammar.txi, doc/interpreter/image.txi,
doc/interpreter/install.txi, doc/interpreter/interp.txi,
doc/interpreter/io.txi, doc/interpreter/matrix.txi,
doc/interpreter/numbers.txi, doc/interpreter/oop.txi,
doc/interpreter/package.txi, doc/interpreter/plot.txi,
doc/interpreter/quad.txi, doc/interpreter/sparse.txi,
doc/interpreter/strings.txi, doc/interpreter/system.txi,
doc/interpreter/vectorize.txi, libinterp/corefcn/balance.cc,
libinterp/corefcn/bitfcns.cc, libinterp/corefcn/cellfun.cc,
libinterp/corefcn/conv2.cc, libinterp/corefcn/data.cc,
libinterp/corefcn/debug.cc, libinterp/corefcn/defaults.cc,
libinterp/corefcn/dirfns.cc, libinterp/corefcn/dlmread.cc,
libinterp/corefcn/error.cc, libinterp/corefcn/file-io.cc,
libinterp/corefcn/find.cc, libinterp/corefcn/gammainc.cc,
libinterp/corefcn/graphics.cc, libinterp/corefcn/help.cc,
libinterp/corefcn/hex2num.cc, libinterp/corefcn/input.cc,
libinterp/corefcn/load-path.cc, libinterp/corefcn/load-save.cc,
libinterp/corefcn/ls-oct-ascii.cc, libinterp/corefcn/lu.cc,
libinterp/corefcn/luinc.cc, libinterp/corefcn/matrix_type.cc,
libinterp/corefcn/oct-hist.cc, libinterp/corefcn/pager.cc,
libinterp/corefcn/pr-output.cc, libinterp/corefcn/pt-jit.cc,
libinterp/corefcn/qz.cc, libinterp/corefcn/rand.cc,
libinterp/corefcn/regexp.cc, libinterp/corefcn/schur.cc,
libinterp/corefcn/sighandlers.cc, libinterp/corefcn/sparse.cc,
libinterp/corefcn/spparms.cc, libinterp/corefcn/str2double.cc,
libinterp/corefcn/svd.cc, libinterp/corefcn/symtab.cc,
libinterp/corefcn/syscalls.cc, libinterp/corefcn/toplev.cc,
libinterp/corefcn/tril.cc, libinterp/corefcn/typecast.cc,
libinterp/corefcn/utils.cc, libinterp/corefcn/variables.cc,
libinterp/dldfcn/__init_fltk__.cc, libinterp/dldfcn/chol.cc,
libinterp/dldfcn/colamd.cc, libinterp/dldfcn/fftw.cc, libinterp/dldfcn/qr.cc,
libinterp/dldfcn/symbfact.cc, libinterp/octave-value/ov-base.cc,
libinterp/octave-value/ov-fcn-handle.cc,
libinterp/octave-value/ov-fcn-inline.cc, libinterp/octave-value/ov-java.cc,
libinterp/octave-value/ov-range.cc, libinterp/octave-value/ov-struct.cc,
libinterp/octave-value/ov-usr-fcn.cc, libinterp/parse-tree/oct-parse.in.yy,
libinterp/parse-tree/pt-binop.cc, libinterp/parse-tree/pt-eval.cc,
libinterp/parse-tree/pt-mat.cc, scripts/@ftp/ftp.m,
scripts/deprecated/java_convert_matrix.m, scripts/deprecated/java_debug.m,
scripts/deprecated/java_unsigned_conversion.m, scripts/deprecated/shell_cmd.m,
scripts/general/dblquad.m, scripts/general/display.m,
scripts/general/genvarname.m, scripts/general/idivide.m,
scripts/general/interp1.m, scripts/general/interp2.m,
scripts/general/interp3.m, scripts/general/interpn.m, scripts/general/isa.m,
scripts/general/profexplore.m, scripts/general/profile.m,
scripts/general/quadgk.m, scripts/general/randi.m, scripts/general/structfun.m,
scripts/general/subsindex.m, scripts/general/triplequad.m,
scripts/geometry/griddata.m, scripts/geometry/griddata3.m,
scripts/geometry/griddatan.m, scripts/geometry/voronoi.m, scripts/help/help.m,
scripts/help/lookfor.m, scripts/image/cmpermute.m, scripts/image/colormap.m,
scripts/image/image.m, scripts/image/imagesc.m, scripts/image/imfinfo.m,
scripts/image/imformats.m, scripts/image/imread.m, scripts/image/imshow.m,
scripts/image/imwrite.m, scripts/image/ind2gray.m, scripts/image/lines.m,
scripts/image/rgb2ind.m, scripts/image/spinmap.m, scripts/io/dlmwrite.m,
scripts/io/strread.m, scripts/io/textread.m, scripts/io/textscan.m,
scripts/java/javaclasspath.m, scripts/java/usejava.m,
scripts/miscellaneous/bzip2.m, scripts/miscellaneous/computer.m,
scripts/miscellaneous/copyfile.m, scripts/miscellaneous/debug.m,
scripts/miscellaneous/dos.m, scripts/miscellaneous/edit.m,
scripts/miscellaneous/gzip.m, scripts/miscellaneous/license.m,
scripts/miscellaneous/mkoctfile.m, scripts/miscellaneous/movefile.m,
scripts/miscellaneous/parseparams.m, scripts/miscellaneous/unix.m,
scripts/optimization/fminbnd.m, scripts/optimization/fminsearch.m,
scripts/optimization/fminunc.m, scripts/optimization/fsolve.m,
scripts/optimization/fzero.m, scripts/optimization/glpk.m,
scripts/optimization/lsqnonneg.m, scripts/optimization/optimset.m,
scripts/optimization/pqpnonneg.m, scripts/pkg/pkg.m, scripts/plot/allchild.m,
scripts/plot/ancestor.m, scripts/plot/area.m, scripts/plot/axis.m,
scripts/plot/bar.m, scripts/plot/barh.m, scripts/plot/box.m,
scripts/plot/caxis.m, scripts/plot/cla.m, scripts/plot/clabel.m,
scripts/plot/clf.m, scripts/plot/close.m, scripts/plot/colorbar.m,
scripts/plot/daspect.m, scripts/plot/ezmesh.m, scripts/plot/ezmeshc.m,
scripts/plot/ezsurf.m, scripts/plot/ezsurfc.m, scripts/plot/findall.m,
scripts/plot/findobj.m, scripts/plot/gcbo.m, scripts/plot/gcf.m,
scripts/plot/gco.m, scripts/plot/grid.m, scripts/plot/guihandles.m,
scripts/plot/hdl2struct.m, scripts/plot/hidden.m, scripts/plot/hold.m,
scripts/plot/isonormals.m, scripts/plot/isosurface.m, scripts/plot/legend.m,
scripts/plot/mesh.m, scripts/plot/meshc.m, scripts/plot/meshz.m,
scripts/plot/newplot.m, scripts/plot/orient.m, scripts/plot/pareto.m,
scripts/plot/patch.m, scripts/plot/pbaspect.m, scripts/plot/pcolor.m,
scripts/plot/plot.m, scripts/plot/print.m,
scripts/plot/private/__add_default_menu__.m, scripts/plot/quiver.m,
scripts/plot/quiver3.m, scripts/plot/refreshdata.m, scripts/plot/saveas.m,
scripts/plot/scatter.m, scripts/plot/scatter3.m, scripts/plot/shading.m,
scripts/plot/shrinkfaces.m, scripts/plot/slice.m, scripts/plot/stem.m,
scripts/plot/stem3.m, scripts/plot/struct2hdl.m, scripts/plot/subplot.m,
scripts/plot/surf.m, scripts/plot/surfc.m, scripts/plot/surfl.m,
scripts/plot/tetramesh.m, scripts/plot/uigetfile.m, scripts/plot/uimenu.m,
scripts/plot/uiputfile.m, scripts/plot/waterfall.m, scripts/plot/whitebg.m,
scripts/plot/xlim.m, scripts/plot/ylim.m, scripts/plot/zlim.m,
scripts/polynomial/conv.m, scripts/polynomial/polyout.m,
scripts/polynomial/splinefit.m, scripts/set/ismember.m, scripts/set/powerset.m,
scripts/set/setdiff.m, scripts/set/union.m, scripts/set/unique.m,
scripts/signal/detrend.m, scripts/signal/filter2.m, scripts/signal/freqz.m,
scripts/signal/periodogram.m, scripts/signal/spectral_adf.m,
scripts/signal/spectral_xdf.m, scripts/sparse/eigs.m, scripts/sparse/svds.m,
scripts/specfun/legendre.m, scripts/special-matrix/gallery.m,
scripts/statistics/base/mean.m, scripts/statistics/base/moment.m,
scripts/statistics/tests/cor_test.m,
scripts/statistics/tests/kolmogorov_smirnov_test.m,
scripts/statistics/tests/kolmogorov_smirnov_test_2.m,
scripts/statistics/tests/kruskal_wallis_test.m,
scripts/statistics/tests/prop_test_2.m, scripts/statistics/tests/sign_test.m,
scripts/statistics/tests/t_test.m, scripts/statistics/tests/t_test_2.m,
scripts/statistics/tests/t_test_regression.m,
scripts/statistics/tests/u_test.m, scripts/statistics/tests/var_test.m,
scripts/statistics/tests/welch_test.m,
scripts/statistics/tests/wilcoxon_test.m, scripts/statistics/tests/z_test.m,
scripts/statistics/tests/z_test_2.m, scripts/strings/base2dec.m,
scripts/strings/index.m, scripts/strings/isstrprop.m,
scripts/strings/mat2str.m, scripts/strings/regexptranslate.m,
scripts/strings/rindex.m, scripts/strings/str2num.m, scripts/strings/strcat.m,
scripts/strings/strjust.m, scripts/strings/strmatch.m,
scripts/strings/validatestring.m, scripts/testfun/demo.m,
scripts/testfun/example.m, scripts/testfun/test.m, scripts/time/addtodate.m,
scripts/time/asctime.m, scripts/time/datestr.m, scripts/time/datetick.m,
scripts/time/weekday.m, scripts/ui/errordlg.m, scripts/ui/helpdlg.m,
scripts/ui/inputdlg.m, scripts/ui/listdlg.m, scripts/ui/msgbox.m,
scripts/ui/questdlg.m, scripts/ui/warndlg.m: Use new @qcode macro.
author | Rik <rik@octave.org> |
---|---|
date | Mon, 19 Aug 2013 20:46:38 -0700 |
parents | 0f143f68078d |
children | d63878346099 |
line wrap: on
line source
/* Copyright (C) 1996-2012 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 <iostream> #include "lo-ieee.h" #include "lo-utils.h" #include "defun.h" #include "variables.h" #include "gripes.h" #include "mxarray.h" #include "ops.h" #include "oct-obj.h" #include "ov-range.h" #include "ov-re-mat.h" #include "ov-scalar.h" #include "pr-output.h" #include "byte-swap.h" #include "ls-ascii-helper.h" #include "ls-hdf5.h" #include "ls-utils.h" // If TRUE, allow ranges with non-integer elements as array indices. bool Vallow_noninteger_range_as_index = false; DEFINE_OCTAVE_ALLOCATOR (octave_range); DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_range, "range", "double"); static octave_base_value * default_numeric_conversion_function (const octave_base_value& a) { CAST_CONV_ARG (const octave_range&); return new octave_matrix (v.matrix_value ()); } octave_base_value::type_conv_info octave_range::numeric_conversion_function (void) const { return octave_base_value::type_conv_info (default_numeric_conversion_function, octave_matrix::static_type_id ()); } octave_base_value * octave_range::try_narrowing_conversion (void) { octave_base_value *retval = 0; switch (range.nelem ()) { case 1: retval = new octave_scalar (range.base ()); break; case 0: retval = new octave_matrix (Matrix (1, 0)); break; case -2: retval = new octave_matrix (range.matrix_value ()); break; default: break; } return retval; } octave_value octave_range::subsref (const std::string& type, const std::list<octave_value_list>& idx) { octave_value retval; switch (type[0]) { case '(': retval = do_index_op (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 (); } return retval.next_subsref (type, idx); } octave_value octave_range::do_index_op (const octave_value_list& idx, bool resize_ok) { if (idx.length () == 1 && ! resize_ok) { octave_value retval; // The range can handle a single subscript. idx_vector i = idx(0).index_vector (); if (! error_state) { if (i.is_scalar () && i(0) < range.nelem ()) retval = range.elem (i(0)); else retval = range.index (i); } return retval; } else { octave_value tmp (new octave_matrix (range.matrix_value ())); return tmp.do_index_op (idx, resize_ok); } } idx_vector octave_range::index_vector (void) const { if (idx_cache) return *idx_cache; else { if (! Vallow_noninteger_range_as_index || range.all_elements_are_ints ()) return set_idx_cache (idx_vector (range)); else { warning_with_id ("Octave:noninteger-range-as-index", "non-integer range used as index"); return octave_value (matrix_value ()).round ().index_vector (); } } } double octave_range::double_value (bool) const { double retval = lo_ieee_nan_value (); octave_idx_type nel = range.nelem (); if (nel > 0) { gripe_implicit_conversion ("Octave:array-to-scalar", "range", "real scalar"); retval = range.base (); } else gripe_invalid_conversion ("range", "real scalar"); return retval; } float octave_range::float_value (bool) const { float retval = lo_ieee_float_nan_value (); octave_idx_type nel = range.nelem (); if (nel > 0) { gripe_implicit_conversion ("Octave:array-to-scalar", "range", "real scalar"); retval = range.base (); } else gripe_invalid_conversion ("range", "real scalar"); return retval; } charNDArray octave_range::char_array_value (bool) const { const Matrix matrix = range.matrix_value (); charNDArray retval (dims ()); octave_idx_type nel = numel (); for (octave_idx_type i = 0; i < nel; i++) retval.elem (i) = static_cast<char>(matrix.elem (i)); return retval; } octave_value octave_range::all (int dim) const { // FIXME -- this is a potential waste of memory. Matrix m = range.matrix_value (); return m.all (dim); } octave_value octave_range::any (int dim) const { // FIXME -- this is a potential waste of memory. Matrix m = range.matrix_value (); return m.any (dim); } octave_value octave_range::diag (octave_idx_type k) const { return (k == 0 ? octave_value (DiagMatrix (DiagArray2<double> (range.matrix_value ()))) : octave_value (range.diag (k))); } octave_value octave_range::diag (octave_idx_type m, octave_idx_type n) const { Matrix mat = range.matrix_value (); return mat.diag (m, n); } bool octave_range::is_true (void) const { bool retval = false; if (range.nelem () != 0) { // FIXME -- this is a potential waste of memory. Matrix m ((range.matrix_value () . all ()) . all ()); retval = (m.rows () == 1 && m.columns () == 1 && m (0, 0) != 0.0); } return retval; } Complex octave_range::complex_value (bool) const { double tmp = lo_ieee_nan_value (); Complex retval (tmp, tmp); octave_idx_type nel = range.nelem (); if (nel > 0) { gripe_implicit_conversion ("Octave:array-to-scalar", "range", "complex scalar"); retval = range.base (); } else gripe_invalid_conversion ("range", "complex scalar"); return retval; } FloatComplex octave_range::float_complex_value (bool) const { float tmp = lo_ieee_float_nan_value (); FloatComplex retval (tmp, tmp); octave_idx_type nel = range.nelem (); if (nel > 0) { gripe_implicit_conversion ("Octave:array-to-scalar", "range", "complex scalar"); retval = range.base (); } else gripe_invalid_conversion ("range", "complex scalar"); return retval; } boolNDArray octave_range::bool_array_value (bool warn) const { Matrix m = range.matrix_value (); if (m.any_element_is_nan ()) gripe_nan_to_logical_conversion (); else if (warn && m.any_element_not_one_or_zero ()) gripe_logical_conversion (); return boolNDArray (m); } octave_value octave_range::resize (const dim_vector& dv, bool fill) const { NDArray retval = array_value (); if (fill) retval.resize (dv, 0); else retval.resize (dv); return retval; } octave_value octave_range::convert_to_str_internal (bool pad, bool force, char type) const { octave_value tmp (range.matrix_value ()); return tmp.convert_to_str (pad, force, type); } void octave_range::print (std::ostream& os, bool pr_as_read_syntax) const { print_raw (os, pr_as_read_syntax); newline (os); } void octave_range::print_raw (std::ostream& os, bool pr_as_read_syntax) const { octave_print_internal (os, range, pr_as_read_syntax, current_print_indent_level ()); } bool octave_range::print_name_tag (std::ostream& os, const std::string& name) const { bool retval = false; octave_idx_type n = range.nelem (); indent (os); if (n == 0 || n == 1) os << name << " = "; else { os << name << " ="; newline (os); if (! Vcompact_format) newline (os); retval = true; } return retval; } std::string octave_range::short_disp (void) const { std::ostringstream buf; octave_idx_type len = range.nelem (); if (len == 0) buf << "[]"; else { buf << range.base () << ":"; if (len > 1) { if (range.inc () != 1) buf << range.inc () << ":"; buf << range.limit (); } } return buf.str (); } // Skip white space and comments on stream IS. static void skip_comments (std::istream& is) { char c = '\0'; while (is.get (c)) { if (c == ' ' || c == '\t' || c == '\n') ; // Skip whitespace on way to beginning of next line. else break; } skip_until_newline (is, false); } bool octave_range::save_ascii (std::ostream& os) { Range r = range_value (); double base = r.base (); double limit = r.limit (); double inc = r.inc (); octave_idx_type len = r.nelem (); if (inc != 0) os << "# base, limit, increment\n"; else os << "# base, length, increment\n"; octave_write_double (os, base); os << " "; if (inc != 0) octave_write_double (os, limit); else os << len; os << " "; octave_write_double (os, inc); os << "\n"; return true; } bool octave_range::load_ascii (std::istream& is) { // # base, limit, range comment added by save (). skip_comments (is); double base, limit, inc; is >> base >> limit >> inc; if (!is) { error ("load: failed to load range constant"); return false; } if (inc != 0) range = Range (base, limit, inc); else range = Range (base, inc, static_cast<octave_idx_type> (limit)); return true; } bool octave_range::save_binary (std::ostream& os, bool& /* save_as_floats */) { char tmp = LS_DOUBLE; os.write (reinterpret_cast<char *> (&tmp), 1); Range r = range_value (); double bas = r.base (); double lim = r.limit (); double inc = r.inc (); if (inc == 0) lim = r.nelem (); os.write (reinterpret_cast<char *> (&bas), 8); os.write (reinterpret_cast<char *> (&lim), 8); os.write (reinterpret_cast<char *> (&inc), 8); return true; } bool octave_range::load_binary (std::istream& is, bool swap, oct_mach_info::float_format /* fmt */) { char tmp; if (! is.read (reinterpret_cast<char *> (&tmp), 1)) return false; double bas, lim, inc; if (! is.read (reinterpret_cast<char *> (&bas), 8)) return false; if (swap) swap_bytes<8> (&bas); if (! is.read (reinterpret_cast<char *> (&lim), 8)) return false; if (swap) swap_bytes<8> (&lim); if (! is.read (reinterpret_cast<char *> (&inc), 8)) return false; if (swap) swap_bytes<8> (&inc); if (inc != 0) range = Range (bas, lim, inc); else range = Range (bas, inc, static_cast<octave_idx_type> (lim)); return true; } #if defined (HAVE_HDF5) // The following subroutines creates an HDF5 representation of the way // we will store Octave range types (triplets of floating-point numbers). // NUM_TYPE is the HDF5 numeric type to use for storage (e.g. // H5T_NATIVE_DOUBLE to save as 'double'). Note that any necessary // conversions are handled automatically by HDF5. static hid_t hdf5_make_range_type (hid_t num_type) { hid_t type_id = H5Tcreate (H5T_COMPOUND, sizeof (double) * 3); H5Tinsert (type_id, "base", 0 * sizeof (double), num_type); H5Tinsert (type_id, "limit", 1 * sizeof (double), num_type); H5Tinsert (type_id, "increment", 2 * sizeof (double), num_type); return type_id; } bool octave_range::save_hdf5 (hid_t loc_id, const char *name, bool /* save_as_floats */) { hsize_t dimens[3]; hid_t space_hid = -1, type_hid = -1, data_hid = -1; bool retval = true; space_hid = H5Screate_simple (0, dimens, 0); if (space_hid < 0) return false; type_hid = hdf5_make_range_type (H5T_NATIVE_DOUBLE); if (type_hid < 0) { H5Sclose (space_hid); return false; } #if HAVE_HDF5_18 data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); #else data_hid = H5Dcreate (loc_id, name, type_hid, space_hid, H5P_DEFAULT); #endif if (data_hid < 0) { H5Sclose (space_hid); H5Tclose (type_hid); return false; } Range r = range_value (); double range_vals[3]; range_vals[0] = r.base (); range_vals[1] = r.inc () != 0 ? r.limit () : r.nelem (); range_vals[2] = r.inc (); if (H5Dwrite (data_hid, type_hid, H5S_ALL, H5S_ALL, H5P_DEFAULT, range_vals) >= 0) { octave_idx_type nel = r.nelem (); retval = hdf5_add_scalar_attr (data_hid, H5T_NATIVE_IDX, "OCTAVE_RANGE_NELEM", &nel) >= 0; } else retval = false; H5Dclose (data_hid); H5Tclose (type_hid); H5Sclose (space_hid); return retval; } bool octave_range::load_hdf5 (hid_t loc_id, const char *name) { bool retval = false; #if HAVE_HDF5_18 hid_t data_hid = H5Dopen (loc_id, name, H5P_DEFAULT); #else hid_t data_hid = H5Dopen (loc_id, name); #endif hid_t type_hid = H5Dget_type (data_hid); hid_t range_type = hdf5_make_range_type (H5T_NATIVE_DOUBLE); if (! hdf5_types_compatible (type_hid, range_type)) { H5Tclose (range_type); H5Dclose (data_hid); return false; } hid_t space_hid = H5Dget_space (data_hid); hsize_t rank = H5Sget_simple_extent_ndims (space_hid); if (rank != 0) { H5Tclose (range_type); H5Sclose (space_hid); H5Dclose (data_hid); return false; } double rangevals[3]; if (H5Dread (data_hid, range_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, rangevals) >= 0) { retval = true; octave_idx_type nel; if (hdf5_get_scalar_attr (data_hid, H5T_NATIVE_IDX, "OCTAVE_RANGE_NELEM", &nel)) range = Range (rangevals[0], rangevals[2], nel); else { if (rangevals[2] != 0) range = Range (rangevals[0], rangevals[1], rangevals[2]); else range = Range (rangevals[0], rangevals[2], static_cast<octave_idx_type> (rangevals[1])); } } H5Tclose (range_type); H5Sclose (space_hid); H5Dclose (data_hid); return retval; } #endif mxArray * octave_range::as_mxArray (void) const { mxArray *retval = new mxArray (mxDOUBLE_CLASS, dims (), mxREAL); double *pr = static_cast<double *> (retval->get_data ()); mwSize nel = numel (); Matrix m = matrix_value (); const double *p = m.data (); for (mwSize i = 0; i < nel; i++) pr[i] = p[i]; return retval; } DEFUN (allow_noninteger_range_as_index, args, nargout, "-*- texinfo -*-\n\ @deftypefn {Built-in Function} {@var{val} =} allow_noninteger_range_as_index ()\n\ @deftypefnx {Built-in Function} {@var{old_val} =} allow_noninteger_range_as_index (@var{new_val})\n\ @deftypefnx {Built-in Function} {} allow_noninteger_range_as_index (@var{new_val}, \"local\")\n\ Query or set the internal variable that controls whether non-integer\n\ ranges are allowed as indices. This might be useful for @sc{matlab}\n\ compatibility; however, it is still not entirely compatible because\n\ @sc{matlab} treats the range expression differently in different contexts.\n\ \n\ When called from inside a function with the @qcode{\"local\"} option, the\n\ variable is changed locally for the function and any subroutines it calls. \n\ The original variable value is restored when exiting the function.\n\ @end deftypefn") { return SET_INTERNAL_VARIABLE (allow_noninteger_range_as_index); } /* %!test %! x = 0:10; %! save = allow_noninteger_range_as_index (); %! warn_state = warning ("query", "Octave:noninteger-range-as-index"); %! unwind_protect %! allow_noninteger_range_as_index (false); %! fail ("x(2.1:5)"); %! assert (x(2:5), 1:4); %! allow_noninteger_range_as_index (true); %! warning ("off", "Octave:noninteger-range-as-index"); %! assert (x(2.49:5), 1:3); %! assert (x(2.5:5), 2:4); %! assert (x(2.51:5), 2:4); %! unwind_protect_cleanup %! allow_noninteger_range_as_index (save); %! warning (warn_state.state, warn_state.identifier); %! end_unwind_protect */