ov-base.cc File Reference

#include <istream>
#include <limits>
#include <ostream>
#include "lo-ieee.h"
#include "lo-mappers.h"
#include "defun.h"
#include "errwarn.h"
#include "interpreter-private.h"
#include "interpreter.h"
#include "mxarray.h"
#include "oct-hdf5.h"
#include "oct-lvalue.h"
#include "oct-map.h"
#include "oct-stream.h"
#include "ops.h"
#include "ov-base.h"
#include "ov-cell.h"
#include "ov-ch-mat.h"
#include "ov-classdef.h"
#include "ov-complex.h"
#include "ov-cx-mat.h"
#include "ov-fcn-handle.h"
#include "ov-range.h"
#include "ov-re-mat.h"
#include "ov-scalar.h"
#include "ov-str-mat.h"
#include "ovl.h"
#include "parse.h"
#include "pr-flt-fmt.h"
#include "pr-output.h"
#include "utils.h"
#include "variables.h"
#include "ov-inline.h"

Go to the source code of this file.

Macros
#define	INT_CONV_METHOD(T, F)

Functions
builtin_type_t	btyp_mixed_numeric (builtin_type_t x, builtin_type_t y)
	Determine the resulting type for a possible mixed-type operation. More...
bool	called_from_builtin ()
void	install_base_type_conversions (octave::type_info &ti)
octave_value	make_idx_args (const std::string &type, const std::list< octave_value_list > &idx, const std::string &who)

Variables
std::string	btyp_class_name [btyp_num_types+1]
bool	Vsparse_auto_mutate = false

Macro Definition Documentation

INT_CONV_METHOD

#define INT_CONV_METHOD	(		T,
			F
	)

Value:

  T                                                                     \
  octave_base_value::F ## _value (bool require_int, bool frc_str_conv) const \
  {                                                                     \
    T retval = 0;                                                       \
                                                                        \
    double d = 0.0;                                                     \
                                                                        \
    try                                                                 \
      {                                                                 \
        d = double_value (frc_str_conv);                                \
      }                                                                 \
    catch (octave::execution_exception& ee)                               \
      {                                                                 \
        err_wrong_type_arg (ee, "octave_base_value::" #F "_value ()", type_name ()); \
      }                                                                 \
                                                                        \
    static const double out_of_range_top                                \
      = static_cast<double> (std::numeric_limits<T>::max ()) + 1.;      \
    if (require_int && octave::math::x_nint (d) != d)                   \
      error_with_cfn ("conversion of %g to " #T " value failed", d);    \
    else if (d < std::numeric_limits<T>::min ())                        \
      retval = std::numeric_limits<T>::min ();                          \
    else if (d >= out_of_range_top)                                     \
      retval = std::numeric_limits<T>::max ();                          \
    else                                                                \
      retval = static_cast<T> (octave::math::fix (d));                  \
                                                                        \
    return retval;                                                      \
  }

Definition at line 518 of file ov-base.cc.

Function Documentation

btyp_mixed_numeric()

builtin_type_t btyp_mixed_numeric	(	builtin_type_t	x,
		builtin_type_t	y
	)

Determine the resulting type for a possible mixed-type operation.

Rules for the resulting type:

• bool -> double
• single + double -> single
• real + complex -> complex
• integer + real -> integer
• uint + uint -> uint (the bigger one)
• sint + sint -> sint (the bigger one)

Returns

The resulting type or "unknown type", if the resulting type cannot be determined.

Definition at line 67 of file ov-base.cc.

References btyp_bool, btyp_double, btyp_unknown, and x.

called_from_builtin()

bool called_from_builtin

(

)

Definition at line 1524 of file ov-base.cc.

References __get_evaluator__(), and octave_function::name().

Referenced by octave_class::size(), octave_class::subsref(), and octave_class::xnumel().

install_base_type_conversions()

void install_base_type_conversions

(

octave::type_info &

ti

)

Definition at line 1542 of file ov-base.cc.

References INSTALL_ASSIGNCONV_TI, and INSTALL_WIDENOP_TI.

Referenced by install_ops().

make_idx_args()

octave_value make_idx_args	(	const std::string &	type,
		const std::list< octave_value_list > &	idx,
		const std::string &	who
	)

Definition at line 1461 of file ov-base.cc.

References error(), and len.

Variable Documentation

btyp_class_name

std::string btyp_class_name[btyp_num_types+1]

Initial value:

=
{
  "double", "single", "double", "single",
  "int8", "int16", "int32", "int64",
  "uint8", "uint16", "uint32", "uint64",
  "logical", "char",
  "struct", "cell", "function_handle", "unknown"
}

Definition at line 91 of file ov-base.cc.

Vsparse_auto_mutate

bool Vsparse_auto_mutate = false

Definition at line 104 of file ov-base.cc.