mx-inlines.cc File Reference

#include <cstddef>
#include <cmath>
#include <algorithm>
#include "Array-util.h"
#include "Array.h"
#include "bsxfun.h"
#include "oct-cmplx.h"
#include "oct-inttypes.h"
#include "oct-locbuf.h"

Include dependency graph for mx-inlines.cc:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DEFMINMAXSPEC(T, F, OP)
#define	DEFMXBINOP(F, OP)
#define	DEFMXBINOPEQ(F, OP)
#define	DEFMXBOOLOP(F, NOT1, OP, NOT2)
#define	DEFMXCMPOP(F, OP)
#define	octave_mx_inlines_h   1
#define	OP_CUM_FCN(F, TSRC, TRES, OP)
#define	OP_CUM_FCN2(F, TSRC, TRES, OP)
#define	OP_CUM_FCNN(F, TSRC, TRES)
#define	OP_CUMMINMAX_FCN(F, OP)
#define	OP_CUMMINMAX_FCN2(F, OP)
#define	OP_CUMMINMAX_FCNN(F)
#define	OP_MINMAX_FCN(F, OP)
#define	OP_MINMAX_FCN2(F, OP)
#define	OP_MINMAX_FCNN(F)
#define	OP_RED_ALLC(ac, el)
#define	OP_RED_ALLR(ac, el)   ac &= xis_true (el)
#define	OP_RED_ANYC(ac, el)
#define	OP_RED_ANYR(ac, el)   ac |= xis_true (el)
#define	OP_RED_FCN(F, TSRC, TRES, OP, ZERO)
#define	OP_RED_FCN2(F, TSRC, TRES, OP, ZERO)
#define	OP_RED_FCNN(F, TSRC, TRES)
#define	OP_RED_PROD(ac, el)   ac *= el
#define	OP_RED_SUM(ac, el)   ac += el
#define	OP_RED_SUMSQ(ac, el)   ac += ((el)*(el))
#define	OP_RED_SUMSQC(ac, el)   ac += cabsq (el)
#define	OP_ROW_SHORT_CIRCUIT(F, PRED, ZERO)
#define	PROMOTE_DOUBLE(T)    typename subst_template_param<std::complex, T, double>::type

Functions
template<typename T >
T	cabsq (const std::complex< T > &c)
template<typename R , typename X , typename Y >
Array< R >	do_mm_binary_op (const Array< X > &x, const Array< Y > &y, void(*op)(size_t, R *, const X *, const Y *), void(*op1)(size_t, R *, X, const Y *), void(*op2)(size_t, R *, const X *, Y), const char *opname)
template<typename R , typename X >
Array< R > &	do_mm_inplace_op (Array< R > &r, const Array< X > &x, void(*op)(size_t, R *, const X *), void(*op1)(size_t, R *, X), const char *opname)
template<typename R , typename X , typename Y >
Array< R >	do_ms_binary_op (const Array< X > &x, const Y &y, void(*op)(size_t, R *, const X *, Y))
template<typename R , typename X >
Array< R > &	do_ms_inplace_op (Array< R > &r, const X &x, void(*op)(size_t, R *, X))
template<typename T >
bool	do_mx_check (const Array< T > &a, bool(*op)(size_t, const T *))
template<typename R , typename T >
Array< R >	do_mx_cum_op (const Array< T > &src, int dim, void(*mx_cum_op)(const T *, R *, octave_idx_type, octave_idx_type, octave_idx_type))
template<typename R >
Array< R >	do_mx_cumminmax_op (const Array< R > &src, Array< octave_idx_type > &idx, int dim, void(*mx_cumminmax_op)(const R *, R *, octave_idx_type *, octave_idx_type, octave_idx_type, octave_idx_type))
template<typename R >
Array< R >	do_mx_cumminmax_op (const Array< R > &src, int dim, void(*mx_cumminmax_op)(const R *, R *, octave_idx_type, octave_idx_type, octave_idx_type))
template<typename R >
Array< R >	do_mx_diff_op (const Array< R > &src, int dim, octave_idx_type order, void(*mx_diff_op)(const R *, R *, octave_idx_type, octave_idx_type, octave_idx_type, octave_idx_type))
template<typename R >
Array< R > &	do_mx_inplace_op (Array< R > &r, void(*op)(size_t, R *))
template<typename R >
Array< R >	do_mx_minmax_op (const Array< R > &src, Array< octave_idx_type > &idx, int dim, void(*mx_minmax_op)(const R *, R *, octave_idx_type *, octave_idx_type, octave_idx_type, octave_idx_type))
template<typename R >
Array< R >	do_mx_minmax_op (const Array< R > &src, int dim, void(*mx_minmax_op)(const R *, R *, octave_idx_type, octave_idx_type, octave_idx_type))
template<typename R , typename T >
Array< R >	do_mx_red_op (const Array< T > &src, int dim, void(*mx_red_op)(const T *, R *, octave_idx_type, octave_idx_type, octave_idx_type))
template<typename R , typename X , R fun>
Array< R >	do_mx_unary_map (const Array< X > &x)
template<typename R , typename X >
Array< R >	do_mx_unary_op (const Array< X > &x, void(*op)(size_t, R *, const X *))
template<typename R , typename X , typename Y >
Array< R >	do_sm_binary_op (const X &x, const Array< Y > &y, void(*op)(size_t, R *, X, const Y *))
	for (octave_idx_type i=0;i< n;i++) ac+ = i
void	get_extent_triplet (const dim_vector &dims, int &dim, octave_idx_type &l, octave_idx_type &n, octave_idx_type &u)
template<typename T >
bool	logical_value (const octave_int< T > &x)
template<typename T >
bool	logical_value (const std::complex< T > &x)
template<typename T >
bool	logical_value (T x)
template<typename R , typename X , typename Y >
void	mx_inline_add (size_t n, R *r, const X *x, const Y *y)
template<typename R , typename X , typename Y >
void	mx_inline_add (size_t n, R *r, const X *x, Y y)
template<typename R , typename X , typename Y >
void	mx_inline_add (size_t n, R *r, X x, const Y *y)
template<typename R , typename X >
void	mx_inline_add2 (size_t n, R *r, const X *x)
template<typename R , typename X >
void	mx_inline_add2 (size_t n, R *r, X x)
template<typename T >
void	mx_inline_all (const T *v, bool *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_all (const T *v, bool *r, octave_idx_type m, octave_idx_type n)
template<typename T >
bool	mx_inline_all_finite (size_t n, const T *x)
template<typename T >
bool	mx_inline_all_real (size_t n, const std::complex< T > *x)
template<typename X , typename Y >
void	mx_inline_and (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_and (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_and (size_t n, bool *r, X x, const Y *y)
template<typename X >
void	mx_inline_and2 (size_t n, bool *r, const X *x)
template<typename X >
void	mx_inline_and2 (size_t n, bool *r, X x)
template<typename X , typename Y >
void	mx_inline_and_not (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_and_not (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_and_not (size_t n, bool *r, X x, const Y *y)
template<typename T >
void	mx_inline_any (const T *v, bool *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
bool	mx_inline_any_nan (size_t n, const T *x)
template<typename T >
bool	mx_inline_any_negative (size_t n, const T *x)
template<typename T >
bool	mx_inline_any_positive (size_t n, const T *x)
template<typename T >
void	mx_inline_count (const bool *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_cumcount (const bool *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_cumcount (const bool *v, T *r, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_cumcount (const bool *v, T *r, octave_idx_type n)
template<typename T >
void	mx_inline_cummax (const T *v, T *r, octave_idx_type *ri, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_cummax (const T *v, T *r, octave_idx_type *ri, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_cummax (const T *v, T *r, octave_idx_type *ri, octave_idx_type n)
template<typename T >
void	mx_inline_cummax (const T *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_cummax (const T *v, T *r, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_cummax (const T *v, T *r, octave_idx_type n)
template<typename T >
void	mx_inline_cummin (const T *v, T *r, octave_idx_type *ri, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_cummin (const T *v, T *r, octave_idx_type *ri, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_cummin (const T *v, T *r, octave_idx_type *ri, octave_idx_type n)
template<typename T >
void	mx_inline_cummin (const T *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_cummin (const T *v, T *r, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_cummin (const T *v, T *r, octave_idx_type n)
template<typename T >
void	mx_inline_cumprod (const T *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_cumprod (const T *v, T *r, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_cumprod (const T *v, T *r, octave_idx_type n)
template<typename T >
void	mx_inline_cumsum (const T *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_cumsum (const T *v, T *r, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_cumsum (const T *v, T *r, octave_idx_type n)
template<typename T >
void	mx_inline_diff (const T *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u, octave_idx_type order)
template<typename T >
void	mx_inline_diff (const T *v, T *r, octave_idx_type m, octave_idx_type n, octave_idx_type order)
template<typename T >
void	mx_inline_diff (const T *v, T *r, octave_idx_type n, octave_idx_type order)
template<typename R , typename X , typename Y >
void	mx_inline_div (size_t n, R *r, const X *x, const Y *y)
template<typename R , typename X , typename Y >
void	mx_inline_div (size_t n, R *r, const X *x, Y y)
template<typename R , typename X , typename Y >
void	mx_inline_div (size_t n, R *r, X x, const Y *y)
template<typename R , typename X >
void	mx_inline_div2 (size_t n, R *r, const X *x)
template<typename R , typename X >
void	mx_inline_div2 (size_t n, R *r, X x)
template<typename T >
void	mx_inline_dprod (const T *v, typename subst_template_param< std::complex, T, double >::type *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_dsum (const T *v, typename subst_template_param< std::complex, T, double >::type *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename X , typename Y >
void	mx_inline_eq (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_eq (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_eq (size_t n, bool *r, X x, const Y *y)
template<typename T1 , typename T2 >
bool	mx_inline_equal (size_t n, const T1 *x, const T2 *y)
template<typename R , typename S >
void	mx_inline_fill (size_t n, R *r, S s)
template<typename X , typename Y >
void	mx_inline_ge (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_ge (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_ge (size_t n, bool *r, X x, const Y *y)
template<typename X , typename Y >
void	mx_inline_gt (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_gt (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_gt (size_t n, bool *r, X x, const Y *y)
template<typename T >
void	mx_inline_imag (size_t n, T *r, const std::complex< T > *x)
template<typename X >
void	mx_inline_iszero (size_t n, bool *r, const X *x)
template<typename X , typename Y >
void	mx_inline_le (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_le (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_le (size_t n, bool *r, X x, const Y *y)
template<typename X , typename Y >
void	mx_inline_lt (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_lt (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_lt (size_t n, bool *r, X x, const Y *y)
template<typename R , typename X , R fun>
void	mx_inline_map (size_t n, R *r, const X *x)
template<typename T >
void	mx_inline_max (const T *v, T *r, octave_idx_type *ri, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_max (const T *v, T *r, octave_idx_type *ri, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_max (const T *v, T *r, octave_idx_type *ri, octave_idx_type n)
template<typename T >
void	mx_inline_max (const T *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_max (const T *v, T *r, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_max (const T *v, T *r, octave_idx_type n)
template<typename T >
void	mx_inline_min (const T *v, T *r, octave_idx_type *ri, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_min (const T *v, T *r, octave_idx_type *ri, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_min (const T *v, T *r, octave_idx_type *ri, octave_idx_type n)
template<typename T >
void	mx_inline_min (const T *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_min (const T *v, T *r, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_min (const T *v, T *r, octave_idx_type n)
template<typename R , typename X , typename Y >
void	mx_inline_mul (size_t n, R *r, const X *x, const Y *y)
template<typename R , typename X , typename Y >
void	mx_inline_mul (size_t n, R *r, const X *x, Y y)
template<typename R , typename X , typename Y >
void	mx_inline_mul (size_t n, R *r, X x, const Y *y)
template<typename R , typename X >
void	mx_inline_mul2 (size_t n, R *r, const X *x)
template<typename R , typename X >
void	mx_inline_mul2 (size_t n, R *r, X x)
template<typename X , typename Y >
void	mx_inline_ne (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_ne (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_ne (size_t n, bool *r, X x, const Y *y)
template<typename X >
void	mx_inline_not (size_t n, bool *r, const X *x)
void	mx_inline_not2 (size_t n, bool *r)
template<typename X , typename Y >
void	mx_inline_not_and (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_not_and (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_not_and (size_t n, bool *r, X x, const Y *y)
template<typename X , typename Y >
void	mx_inline_not_or (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_not_or (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_not_or (size_t n, bool *r, X x, const Y *y)
template<typename X >
void	mx_inline_notzero (size_t n, bool *r, const X *x)
template<typename X , typename Y >
void	mx_inline_or (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_or (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_or (size_t n, bool *r, X x, const Y *y)
template<typename X >
void	mx_inline_or2 (size_t n, bool *r, const X *x)
template<typename X >
void	mx_inline_or2 (size_t n, bool *r, X x)
template<typename X , typename Y >
void	mx_inline_or_not (size_t n, bool *r, const X *x, const Y *y)
template<typename X , typename Y >
void	mx_inline_or_not (size_t n, bool *r, const X *x, Y y)
template<typename X , typename Y >
void	mx_inline_or_not (size_t n, bool *r, X x, const Y *y)
template<typename R , typename X , typename Y >
void	mx_inline_pow (size_t n, R *r, const X *x, const Y *y)
template<typename R , typename X , typename Y >
void	mx_inline_pow (size_t n, R *r, const X *x, Y y)
template<typename R , typename X , typename Y >
void	mx_inline_pow (size_t n, R *r, X x, const Y *y)
template<typename T >
void	mx_inline_prod (const T *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_real (size_t n, T *r, const std::complex< T > *x)
template<typename R , typename X , typename Y >
void	mx_inline_sub (size_t n, R *r, const X *x, const Y *y)
template<typename R , typename X , typename Y >
void	mx_inline_sub (size_t n, R *r, const X *x, Y y)
template<typename R , typename X , typename Y >
void	mx_inline_sub (size_t n, R *r, X x, const Y *y)
template<typename R , typename X >
void	mx_inline_sub2 (size_t n, R *r, const X *x)
template<typename R , typename X >
void	mx_inline_sub2 (size_t n, R *r, X x)
template<typename T >
T	mx_inline_sum (const T *v, octave_idx_type n)
template<typename T >
void	mx_inline_sum (const T *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_sumsq (const std::complex< T > *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
T	mx_inline_sumsq (const T *v, octave_idx_type n)
template<typename T >
void	mx_inline_sumsq (const T *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_sumsq (const T *v, T *r, octave_idx_type m, octave_idx_type n)
template<typename R , typename X >
void	mx_inline_uminus (size_t n, R *r, const X *x)
template<typename R >
void	mx_inline_uminus2 (size_t n, R *r)
template<typename T >
void	mx_inline_xmax (size_t n, T *r, const T *x, const T *y)
template<typename T >
void	mx_inline_xmax (size_t n, T *r, const T *x, T y)
template<typename T >
void	mx_inline_xmax (size_t n, T *r, T x, const T *y)
template<>
void	mx_inline_xmax< double > (size_t n, double *r, const double *x, double y)
template<>
void	mx_inline_xmax< double > (size_t n, double *r, double x, const double *y)
template<>
void	mx_inline_xmax< float > (size_t n, float *r, const float *x, float y)
template<>
void	mx_inline_xmax< float > (size_t n, float *r, float x, const float *y)
template<typename T >
void	mx_inline_xmin (size_t n, T *r, const T *x, const T *y)
template<typename T >
void	mx_inline_xmin (size_t n, T *r, const T *x, T y)
template<typename T >
void	mx_inline_xmin (size_t n, T *r, T x, const T *y)
template<>
void	mx_inline_xmin< double > (size_t n, double *r, const double *x, double y)
template<>
void	mx_inline_xmin< double > (size_t n, double *r, double x, const double *y)
template<>
void	mx_inline_xmin< float > (size_t n, float *r, const float *x, float y)
template<>
void	mx_inline_xmin< float > (size_t n, float *r, float x, const float *y)
template<typename T >
T	mx_inline_xsum (const T *v, octave_idx_type n)
template<typename T >
void	mx_inline_xsum (const T *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_xsum (const T *v, T *r, octave_idx_type m, octave_idx_type n)
	OOP_RED_FCN (mx_inline_all, T, bool, OP_RED_ALLC, true) template< typename T > inline void mx_inline_sum(const T *v
	OOP_RED_FCN (mx_inline_dsum, T, typename subst_template_param< std::complex, T, double >::type, op_dble_sum, 0.0) template< typename T > inline T mx_inline_count(const bool *v
	OOP_RED_FCN (mx_inline_prod, T, T, OP_RED_PROD, 1) template< typename T > inline typename subst_template_param< std
	OOP_RED_FCN (mx_inline_sumsq, std::complex< T >, T, OP_RED_SUMSQC, 0) template< typename T > inline bool mx_inline_any(const T *v
	OOP_RED_FCN2 (mx_inline_all_r, T, bool, OP_RED_ALLR, true) template< typename T > inline void mx_inline_any(const T *v
	OOP_RED_FCN2 (mx_inline_dsum, T, typename subst_template_param< std::complex, T, double >::type, op_dble_sum, 0.0) template< typename T > inline void mx_inline_count(const bool *v
	OOP_RED_FCN2 (mx_inline_prod, T, T, OP_RED_PROD, 1) template< typename T > inline void mx_inline_dprod(const T *v
	OOP_RED_FCN2 (mx_inline_sumsq, std::complex< T >, T, OP_RED_SUMSQC, 0) template< typename T > inline void mx_inline_any_r(const T *v
void	op_dble_prod (Complex &ac, const FloatComplex &el)
template<typename T >
void	op_dble_prod (double &ac, const octave_int< T > &el)
void	op_dble_prod (double &ac, float el)
void	op_dble_sum (Complex &ac, const FloatComplex &el)
template<typename T >
void	op_dble_sum (double &ac, const octave_int< T > &el)
void	op_dble_sum (double &ac, float el)
template<typename T >
void	twosum_accum (T &s, T &e, const T &x)
bool	xis_false (const Complex &x)
bool	xis_false (const FloatComplex &x)
template<typename T >
bool	xis_false (const octave_int< T > &x)
bool	xis_false (double x)
bool	xis_false (float x)
template<typename T >
bool	xis_false (T x)
bool	xis_true (const Complex &x)
bool	xis_true (const FloatComplex &x)
template<typename T >
bool	xis_true (const octave_int< T > &x)
bool	xis_true (double x)
bool	xis_true (float x)
template<typename T >
bool	xis_true (T x)

Variables
return	ac
else	continue
octave_idx_type *	iact = octave_local_buffer_iact .get ()
T octave_idx_type	m
octave_idx_type	n { T ac = 0
octave_idx_type	nact = m
std::unique_ptr< octave_idx_type[]>	octave_local_buffer_iact { new octave_idx_type [ m ] }
T *	r

Macro Definition Documentation

DEFMINMAXSPEC

#define DEFMINMAXSPEC	(		T,
			F,
			OP
	)

Value:

  template <>                                                   \
  inline void F<T> (size_t n, T *r, const T *x, T y)    \
  {                                                             \
    if (octave::math::isnan (y))                                \
      std::memcpy (r, x, n * sizeof (T));                       \
    else                                                        \
      for (size_t i = 0; i < n; i++)                            \
        r[i] = (x[i] OP y ? x[i] : y);                          \
  }                                                             \
  template <>                                                   \
  inline void F<T> (size_t n, T *r, T x, const T *y)    \
  {                                                             \
    if (octave::math::isnan (x))                                \
      std::memcpy (r, y, n * sizeof (T));                       \
    else                                                        \
      for (size_t i = 0; i < n; i++)                            \
        r[i] = (y[i] OP x ? y[i] : x);                          \
  }

Definition at line 383 of file mx-inlines.cc.

DEFMXBINOP

#define DEFMXBINOP	(		F,
			OP
	)

Value:

  template <typename R, typename X, typename Y>                         \
  inline void F (size_t n, R *r, const X *x, const Y *y)        \
  {                                                                     \
    for (size_t i = 0; i < n; i++)                                      \
      r[i] = x[i] OP y[i];                                              \
  }                                                                     \
  template <typename R, typename X, typename Y>                         \
  inline void F (size_t n, R *r, const X *x, Y y)               \
  {                                                                     \
    for (size_t i = 0; i < n; i++)                                      \
      r[i] = x[i] OP y;                                                 \
  }                                                                     \
  template <typename R, typename X, typename Y>                         \
  inline void F (size_t n, R *r, X x, const Y *y)               \
  {                                                                     \
    for (size_t i = 0; i < n; i++)                                      \
      r[i] = x OP y[i];                                                 \
  }

Definition at line 87 of file mx-inlines.cc.

DEFMXBINOPEQ

#define DEFMXBINOPEQ	(		F,
			OP
	)

Value:

  template <typename R, typename X>                     \
  inline void F (size_t n, R *r, const X *x)    \
  {                                                     \
    for (size_t i = 0; i < n; i++)                      \
      r[i] OP x[i];                                     \
  }                                                     \
  template <typename R, typename X>                     \
  inline void F (size_t n, R *r, X x)           \
  {                                                     \
    for (size_t i = 0; i < n; i++)                      \
      r[i] OP x;                                        \
  }

Definition at line 112 of file mx-inlines.cc.

DEFMXBOOLOP

#define DEFMXBOOLOP	(		F,
			NOT1,
			OP,
			NOT2
	)

Value:

  template <typename X, typename Y>                                     \
  inline void F (size_t n, bool *r, const X *x, const Y *y)     \
  {                                                                     \
    for (size_t i = 0; i < n; i++)                                      \
      r[i] = ((NOT1 logical_value (x[i]))                               \
              OP (NOT2 logical_value (y[i])));                          \
  }                                                                     \
  template <typename X, typename Y>                                     \
  inline void F (size_t n, bool *r, const X *x, Y y)            \
  {                                                                     \
    const bool yy = (NOT2 logical_value (y));                           \
    for (size_t i = 0; i < n; i++)                                      \
      r[i] = (NOT1 logical_value (x[i])) OP yy;                         \
  }                                                                     \
  template <typename X, typename Y>                                     \
  inline void F (size_t n, bool *r, X x, const Y *y)            \
  {                                                                     \
    const bool xx = (NOT1 logical_value (x));                           \
    for (size_t i = 0; i < n; i++)                                      \
      r[i] = xx OP (NOT2 logical_value (y[i]));                         \
  }

Definition at line 193 of file mx-inlines.cc.

DEFMXCMPOP

#define DEFMXCMPOP	(		F,
			OP
	)

Value:

  template <typename X, typename Y>                                     \
  inline void F (size_t n, bool *r, const X *x, const Y *y)     \
  {                                                                     \
    for (size_t i = 0; i < n; i++)                                      \
      r[i] = x[i] OP y[i];                                              \
  }                                                                     \
  template <typename X, typename Y>                                     \
  inline void F (size_t n, bool *r, const X *x, Y y)            \
  {                                                                     \
    for (size_t i = 0; i < n; i++)                                      \
      r[i] = x[i] OP y;                                                 \
  }                                                                     \
  template <typename X, typename Y>                                     \
  inline void F (size_t n, bool *r, X x, const Y *y)            \
  {                                                                     \
    for (size_t i = 0; i < n; i++)                                      \
      r[i] = x OP y[i];                                                 \
  }

Definition at line 131 of file mx-inlines.cc.

octave_mx_inlines_h

#define octave_mx_inlines_h   1

Definition at line 27 of file mx-inlines.cc.

OP_CUM_FCN

#define OP_CUM_FCN	(		F,
			TSRC,
			TRES,
			OP
	)

Value:

  template <typename T>                         \
  inline void                                   \
  F (const TSRC *v, TRES *r, octave_idx_type n) \
  {                                             \
    if (n)                                      \
      {                                         \
        TRES t = r[0] = v[0];                   \
        for (octave_idx_type i = 1; i < n; i++) \
          r[i] = t = t OP v[i];                 \
      }                                         \
  }

Definition at line 854 of file mx-inlines.cc.

OP_CUM_FCN2

#define OP_CUM_FCN2	(		F,
			TSRC,
			TRES,
			OP
	)

Value:

  template <typename T>                                                 \
  inline void                                                           \
  F (const TSRC *v, TRES *r, octave_idx_type m, octave_idx_type n)      \
  {                                                                     \
    if (n)                                                              \
      {                                                                 \
        for (octave_idx_type i = 0; i < m; i++)                         \
          r[i] = v[i];                                                  \
        const T *r0 = r;                                                \
        for (octave_idx_type j = 1; j < n; j++)                         \
          {                                                             \
            r += m; v += m;                                             \
            for (octave_idx_type i = 0; i < m; i++)                     \
              r[i] = r0[i] OP v[i];                                     \
            r0 += m;                                                    \
          }                                                             \
      }                                                                 \
  }

Definition at line 871 of file mx-inlines.cc.

OP_CUM_FCNN

#define OP_CUM_FCNN	(		F,
			TSRC,
			TRES
	)

Value:

  template <typename T>                         \
  inline void                                   \
  F (const TSRC *v, TRES *r, octave_idx_type l, \
     octave_idx_type n, octave_idx_type u)      \
  {                                             \
    if (l == 1)                                 \
      {                                         \
        for (octave_idx_type i = 0; i < u; i++) \
          {                                     \
            F (v, r, n);                        \
            v += n;                             \
            r += n;                             \
          }                                     \
      }                                         \
    else                                        \
      {                                         \
        for (octave_idx_type i = 0; i < u; i++) \
          {                                     \
            F (v, r, l, n);                     \
            v += l*n;                           \
            r += l*n;                           \
          }                                     \
      }                                         \
  }

Definition at line 895 of file mx-inlines.cc.

OP_CUMMINMAX_FCN

#define OP_CUMMINMAX_FCN	(		F,
			OP
	)

Definition at line 1125 of file mx-inlines.cc.

OP_CUMMINMAX_FCN2

#define OP_CUMMINMAX_FCN2	(		F,
			OP
	)

Definition at line 1200 of file mx-inlines.cc.

OP_CUMMINMAX_FCNN

#define OP_CUMMINMAX_FCNN

(

F

)

Definition at line 1330 of file mx-inlines.cc.

OP_MINMAX_FCN

#define OP_MINMAX_FCN	(		F,
			OP
	)

Definition at line 925 of file mx-inlines.cc.

OP_MINMAX_FCN2

#define OP_MINMAX_FCN2	(		F,
			OP
	)

Definition at line 978 of file mx-inlines.cc.

OP_MINMAX_FCNN

#define OP_MINMAX_FCNN

(

F

)

Definition at line 1067 of file mx-inlines.cc.

OP_RED_ALLC

#define OP_RED_ALLC	(		ac,
			el
	)

Value:

  if (xis_false (el))                           \
    {                                           \
      ac = false;                               \
      break;                                    \
    }                                           \
  else                                          \
    continue

Definition at line 729 of file mx-inlines.cc.

OP_RED_ALLR

#define OP_RED_ALLR	(		ac,
			el
	)		ac &= xis_true (el)

OP_RED_ANYC

#define OP_RED_ANYC	(		ac,
			el
	)

Value:

  if (xis_true (el))                            \
    {                                           \
      ac = true;                                \
      break;                                    \
    }                                           \
  else                                          \
    continue

Definition at line 720 of file mx-inlines.cc.

OP_RED_ANYR

#define OP_RED_ANYR	(		ac,
			el
	)		ac |= xis_true (el)

OP_RED_FCN

#define OP_RED_FCN	(		F,
			TSRC,
			TRES,
			OP,
			ZERO
	)

Value:

  template <typename T>                         \
  inline TRES                                   \
  F (const TSRC *v, octave_idx_type n)          \
  {                                             \
    TRES ac = ZERO;                             \
    for (octave_idx_type i = 0; i < n; i++)     \
      OP(ac, v[i]);                             \
    return ac;                                  \
  }

Definition at line 738 of file mx-inlines.cc.

OP_RED_FCN2

#define OP_RED_FCN2	(		F,
			TSRC,
			TRES,
			OP,
			ZERO
	)

Value:

  template <typename T>                                                 \
  inline void                                                           \
  F (const TSRC *v, TRES *r, octave_idx_type m, octave_idx_type n)      \
  {                                                                     \
    for (octave_idx_type i = 0; i < m; i++)                             \
      r[i] = ZERO;                                                      \
    for (octave_idx_type j = 0; j < n; j++)                             \
      {                                                                 \
        for (octave_idx_type i = 0; i < m; i++)                         \
          OP(r[i], v[i]);                                               \
        v += m;                                                         \
      }                                                                 \
  }

OP_RED_FCNN

#define OP_RED_FCNN	(		F,
			TSRC,
			TRES
	)

Value:

  template <typename T>                         \
  inline void                                   \
  F (const TSRC *v, TRES *r, octave_idx_type l, \
     octave_idx_type n, octave_idx_type u)      \
  {                                             \
    if (l == 1)                                 \
      {                                         \
        for (octave_idx_type i = 0; i < u; i++) \
          {                                     \
            r[i] = F<T> (v, n);                 \
            v += n;                             \
          }                                     \
      }                                         \
    else                                        \
      {                                         \
        for (octave_idx_type i = 0; i < u; i++) \
          {                                     \
            F (v, r, l, n);                     \
            v += l*n;                           \
            r += l;                             \
          }                                     \
      }                                         \
  }

Definition at line 819 of file mx-inlines.cc.

OP_RED_PROD

#define OP_RED_PROD	(		ac,
			el
	)		ac *= el

Definition at line 675 of file mx-inlines.cc.

OP_RED_SUM

#define OP_RED_SUM	(		ac,
			el
	)		ac += el

Definition at line 674 of file mx-inlines.cc.

OP_RED_SUMSQ

#define OP_RED_SUMSQ	(		ac,
			el
	)		ac += ((el)*(el))

Definition at line 676 of file mx-inlines.cc.

OP_RED_SUMSQC

#define OP_RED_SUMSQC	(		ac,
			el
	)		ac += cabsq (el)

Definition at line 677 of file mx-inlines.cc.

OP_ROW_SHORT_CIRCUIT

#define OP_ROW_SHORT_CIRCUIT	(		F,
			PRED,
			ZERO
	)

Value:

  template <typename T>                                                 \
  inline void                                                           \
  F (const T *v, bool *r, octave_idx_type m, octave_idx_type n)         \
  {                                                                     \
    if (n <= 8)                                                         \
      return F ## _r (v, r, m, n);                                      \
                                                                        \
    /* FIXME: it may be sub-optimal to allocate the buffer here. */     \
    OCTAVE_LOCAL_BUFFER (octave_idx_type, iact, m);                     \
    for (octave_idx_type i = 0; i < m; i++) iact[i] = i;                \
    octave_idx_type nact = m;                                           \
    for (octave_idx_type j = 0; j < n; j++)                             \
      {                                                                 \
        octave_idx_type k = 0;                                          \
        for (octave_idx_type i = 0; i < nact; i++)                      \
          {                                                             \
            octave_idx_type ia = iact[i];                               \
            if (! PRED (v[ia]))                                         \
              iact[k++] = ia;                                           \
          }                                                             \
        nact = k;                                                       \
        v += m;                                                         \
      }                                                                 \
    for (octave_idx_type i = 0; i < m; i++) r[i] = ! ZERO;              \
    for (octave_idx_type i = 0; i < nact; i++) r[iact[i]] = ZERO;       \
  }

PROMOTE_DOUBLE

#define PROMOTE_DOUBLE

(

T

)

typename subst_template_param<std::complex, T, double>::type

Definition at line 749 of file mx-inlines.cc.

Function Documentation

cabsq()

template<typename T >

T cabsq ( const std::complex< T > &  c )

inline

Definition at line 589 of file mx-inlines.cc.

do_mm_binary_op()

template<typename R , typename X , typename Y >

Array<R> do_mm_binary_op ( const Array< X > &  x, const Array< Y > &  y, void(*)(size_t, R *, const X *, const Y *)  op, void(*)(size_t, R *, X, const Y *)  op1, void(*)(size_t, R *, const X *, Y)  op2, const char *  opname  )

inline

Definition at line 498 of file mx-inlines.cc.

References Array< T >::data(), Array< T >::dims(), do_bsxfun_op(), octave::err_nonconformant(), is_valid_bsxfun(), r, and x.

Referenced by max(), and min().

do_mm_inplace_op()

template<typename R , typename X >

Array<R>& do_mm_inplace_op ( Array< R > &  r, const Array< X > &  x, void(*)(size_t, R *, const X *)  op, void(*)(size_t, R *, X)  op1, const char *  opname  )

inline

Definition at line 542 of file mx-inlines.cc.

References do_inplace_bsxfun_op(), octave::err_nonconformant(), is_valid_inplace_bsxfun(), r, and x.

do_ms_binary_op()

template<typename R , typename X , typename Y >

Array<R> do_ms_binary_op ( const Array< X > &  x, const Y &  y, void(*)(size_t, R *, const X *, Y)  op  )

inline

Definition at line 522 of file mx-inlines.cc.

References r, and x.

Referenced by max(), and min().

do_ms_inplace_op()

template<typename R , typename X >

Array<R>& do_ms_inplace_op ( Array< R > &  r, const X &  x, void(*)(size_t, R *, X)  op  )

inline

Definition at line 561 of file mx-inlines.cc.

References r, and x.

do_mx_check()

template<typename T >

bool do_mx_check ( const Array< T > &  a, bool(*)(size_t, const T *)  op  )

inline

Definition at line 580 of file mx-inlines.cc.

References Array< T >::data(), and Array< T >::numel().

do_mx_cum_op()

template<typename R , typename T >

Array<R> do_mx_cum_op ( const Array< T > &  src, int  dim, void(*)(const T *, R *, octave_idx_type, octave_idx_type, octave_idx_type)  mx_cum_op  )

inline

Definition at line 1554 of file mx-inlines.cc.

do_mx_cumminmax_op() [1/2]

template<typename R >

Array<R> do_mx_cumminmax_op ( const Array< R > &  src, Array< octave_idx_type > &  idx, int  dim, void(*)(const R *, R *, octave_idx_type *, octave_idx_type, octave_idx_type, octave_idx_type)  mx_cumminmax_op  )

inline

Definition at line 1630 of file mx-inlines.cc.

do_mx_cumminmax_op() [2/2]

template<typename R >

Array<R> do_mx_cumminmax_op ( const Array< R > &  src, int  dim, void(*)(const R *, R *, octave_idx_type, octave_idx_type, octave_idx_type)  mx_cumminmax_op  )

inline

Definition at line 1614 of file mx-inlines.cc.

do_mx_diff_op()

template<typename R >

Array<R> do_mx_diff_op ( const Array< R > &  src, int  dim, octave_idx_type  order, void(*)(const R *, R *, octave_idx_type, octave_idx_type, octave_idx_type, octave_idx_type)  mx_diff_op  )

inline

Definition at line 1649 of file mx-inlines.cc.

do_mx_inplace_op()

template<typename R >

Array<R>& do_mx_inplace_op ( Array< R > &  r, void(*)(size_t, R *)  op  )

inline

Definition at line 489 of file mx-inlines.cc.

References r.

do_mx_minmax_op() [1/2]

template<typename R >

Array<R> do_mx_minmax_op ( const Array< R > &  src, Array< octave_idx_type > &  idx, int  dim, void(*)(const R *, R *, octave_idx_type *, octave_idx_type, octave_idx_type, octave_idx_type)  mx_minmax_op  )

inline

Definition at line 1591 of file mx-inlines.cc.

do_mx_minmax_op() [2/2]

template<typename R >

Array<R> do_mx_minmax_op ( const Array< R > &  src, int  dim, void(*)(const R *, R *, octave_idx_type, octave_idx_type, octave_idx_type)  mx_minmax_op  )

inline

Definition at line 1571 of file mx-inlines.cc.

do_mx_red_op()

template<typename R , typename T >

Array<R> do_mx_red_op ( const Array< T > &  src, int  dim, void(*)(const T *, R *, octave_idx_type, octave_idx_type, octave_idx_type)  mx_red_op  )

inline

Definition at line 1530 of file mx-inlines.cc.

do_mx_unary_map()

template<typename R , typename X , R fun>

Array< R > do_mx_unary_map ( const Array< X > &  x )

inline

Definition at line 475 of file mx-inlines.cc.

References x.

do_mx_unary_op()

template<typename R , typename X >

Array<R> do_mx_unary_op ( const Array< X > &  x, void(*)(size_t, R *, const X *)  op  )

inline

Definition at line 463 of file mx-inlines.cc.

References r, and x.

do_sm_binary_op()

template<typename R , typename X , typename Y >

Array<R> do_sm_binary_op ( const X &  x, const Array< Y > &  y, void(*)(size_t, R *, X, const Y *)  op  )

inline

Definition at line 532 of file mx-inlines.cc.

References Array< T >::data(), Array< T >::dims(), r, and x.

Referenced by max(), and min().

for()

for

(

)

= i

Definition at line 756 of file mx-inlines.cc.

Referenced by octave::file_editor_tab::save_file(), and octave::math::sparse_qr< SPARSE_T >::sparse_qr_rep< SPARSE_T >::wide_solve().

get_extent_triplet()

void get_extent_triplet ( const dim_vector &  dims, int &  dim, octave_idx_type &  l, octave_idx_type &  n, octave_idx_type &  u  )

inline

Definition at line 1499 of file mx-inlines.cc.

Referenced by MArray< T >::idx_add_nd().

logical_value() [1/3]

template<typename T >

bool logical_value ( const octave_int< T > &  x )

inline

Definition at line 175 of file mx-inlines.cc.

References x.

logical_value() [2/3]

template<typename T >

bool logical_value ( const std::complex< T > &  x )

inline

Definition at line 168 of file mx-inlines.cc.

References x.

logical_value() [3/3]

template<typename T >

bool logical_value ( T  x )

inline

Definition at line 161 of file mx-inlines.cc.

References x.

Referenced by mx_inline_and2(), mx_inline_not(), and mx_inline_or2().

mx_inline_add() [1/3]

template<typename R , typename X , typename Y >

void mx_inline_add ( size_t  n, R *  r, const X *  x, const Y *  y  )

inline

Definition at line 107 of file mx-inlines.cc.

Referenced by Sparse< T >::assign().

mx_inline_add() [2/3]

template<typename R , typename X , typename Y >

void mx_inline_add ( size_t  n, R *  r, const X *  x, Y  y  )

inline

Definition at line 107 of file mx-inlines.cc.

mx_inline_add() [3/3]

template<typename R , typename X , typename Y >

void mx_inline_add ( size_t  n, R *  r, X  x, const Y *  y  )

inline

Definition at line 107 of file mx-inlines.cc.

mx_inline_add2() [1/2]

template<typename R , typename X >

void mx_inline_add2 ( size_t  n, R *  r, const X *  x  )

inline

Definition at line 126 of file mx-inlines.cc.

Referenced by Sparse< T >::assign(), MArray< T >::idx_add_nd(), ComplexColumnVector::operator+=(), ComplexDiagMatrix::operator+=(), FloatComplexColumnVector::operator+=(), FloatComplexDiagMatrix::operator+=(), FloatComplexMatrix::operator+=(), FloatComplexRowVector::operator+=(), ComplexMatrix::operator+=(), ComplexRowVector::operator+=(), and operator+=().

mx_inline_add2() [2/2]

template<typename R , typename X >

void mx_inline_add2 ( size_t  n, R *  r, X  x  )

inline

Definition at line 126 of file mx-inlines.cc.

mx_inline_all() [1/2]

template<typename T >

void mx_inline_all ( const T *  v, bool *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 852 of file mx-inlines.cc.

mx_inline_all() [2/2]

template<typename T >

void mx_inline_all ( const T *  v, bool *  r, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 817 of file mx-inlines.cc.

Referenced by boolNDArray::all(), charNDArray::all(), ComplexNDArray::all(), NDArray::all(), FloatComplexNDArray::all(), and FloatNDArray::all().

mx_inline_all_finite()

template<typename T >

bool mx_inline_all_finite ( size_t  n, const T *  x  )

inline

Definition at line 270 of file mx-inlines.cc.

References octave::math::isfinite(), n, and x.

Referenced by ComplexNDArray::any_element_is_inf_or_nan(), NDArray::any_element_is_inf_or_nan(), FloatComplexNDArray::any_element_is_inf_or_nan(), and FloatNDArray::any_element_is_inf_or_nan().

mx_inline_all_real()

template<typename T >

bool mx_inline_all_real ( size_t  n, const std::complex< T > *  x  )

inline

Definition at line 309 of file mx-inlines.cc.

References imag(), n, and x.

Referenced by ComplexDiagMatrix::all_elements_are_real(), ComplexNDArray::all_elements_are_real(), SparseComplexMatrix::all_elements_are_real(), FloatComplexDiagMatrix::all_elements_are_real(), and FloatComplexNDArray::all_elements_are_real().

mx_inline_and() [1/3]

template<typename X , typename Y >

void mx_inline_and ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 216 of file mx-inlines.cc.

mx_inline_and() [2/3]

template<typename X , typename Y >

void mx_inline_and ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 216 of file mx-inlines.cc.

mx_inline_and() [3/3]

template<typename X , typename Y >

void mx_inline_and ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 216 of file mx-inlines.cc.

mx_inline_and2() [1/2]

template<typename X >

void mx_inline_and2 ( size_t  n, bool *  r, const X *  x  )

inline

Definition at line 225 of file mx-inlines.cc.

References logical_value(), n, r, and x.

Referenced by mx_el_and_assign().

mx_inline_and2() [2/2]

template<typename X >

void mx_inline_and2 ( size_t  n, bool *  r, X  x  )

inline

Definition at line 233 of file mx-inlines.cc.

References n, r, and x.

mx_inline_and_not() [1/3]

template<typename X , typename Y >

void mx_inline_and_not ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 220 of file mx-inlines.cc.

mx_inline_and_not() [2/3]

template<typename X , typename Y >

void mx_inline_and_not ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 220 of file mx-inlines.cc.

mx_inline_and_not() [3/3]

template<typename X , typename Y >

void mx_inline_and_not ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 220 of file mx-inlines.cc.

mx_inline_any()

template<typename T >

void mx_inline_any ( const T *  v, bool *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 851 of file mx-inlines.cc.

Referenced by boolNDArray::any(), charNDArray::any(), ComplexNDArray::any(), NDArray::any(), FloatComplexNDArray::any(), and FloatNDArray::any().

mx_inline_any_nan()

template<typename T >

bool mx_inline_any_nan ( size_t  n, const T *  x  )

inline

Definition at line 257 of file mx-inlines.cc.

References octave::math::isnan(), n, and x.

Referenced by ComplexNDArray::any_element_is_nan(), NDArray::any_element_is_nan(), FloatComplexNDArray::any_element_is_nan(), and FloatNDArray::any_element_is_nan().

mx_inline_any_negative()

template<typename T >

bool mx_inline_any_negative ( size_t  n, const T *  x  )

inline

Definition at line 283 of file mx-inlines.cc.

References n, and x.

Referenced by NDArray::any_element_is_negative(), and FloatNDArray::any_element_is_negative().

mx_inline_any_positive()

template<typename T >

bool mx_inline_any_positive ( size_t  n, const T *  x  )

inline

Definition at line 296 of file mx-inlines.cc.

References n, and x.

Referenced by NDArray::any_element_is_positive(), and FloatNDArray::any_element_is_positive().

mx_inline_count()

template<typename T >

void mx_inline_count ( const bool *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 846 of file mx-inlines.cc.

mx_inline_cumcount() [1/3]

template<typename T >

void mx_inline_cumcount ( const bool *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 923 of file mx-inlines.cc.

mx_inline_cumcount() [2/3]

template<typename T >

void mx_inline_cumcount ( const bool *  v, T *  r, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 893 of file mx-inlines.cc.

mx_inline_cumcount() [3/3]

template<typename T >

void mx_inline_cumcount ( const bool *  v, T *  r, octave_idx_type  n  )

inline

Definition at line 869 of file mx-inlines.cc.

mx_inline_cummax() [1/6]

template<typename T >

void mx_inline_cummax ( const T *  v, T *  r, octave_idx_type *  ri, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1387 of file mx-inlines.cc.

mx_inline_cummax() [2/6]

template<typename T >

void mx_inline_cummax ( const T *  v, T *  r, octave_idx_type *  ri, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 1328 of file mx-inlines.cc.

mx_inline_cummax() [3/6]

template<typename T >

void mx_inline_cummax	(	const T *	v,
		T *	r,
		octave_idx_type *	ri,
		octave_idx_type	n
	)

Definition at line 1194 of file mx-inlines.cc.

mx_inline_cummax() [4/6]

template<typename T >

void mx_inline_cummax ( const T *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1387 of file mx-inlines.cc.

mx_inline_cummax() [5/6]

template<typename T >

void mx_inline_cummax ( const T *  v, T *  r, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 1328 of file mx-inlines.cc.

mx_inline_cummax() [6/6]

template<typename T >

void mx_inline_cummax	(	const T *	v,
		T *	r,
		octave_idx_type	n
	)

Definition at line 1194 of file mx-inlines.cc.

Referenced by ComplexNDArray::cummax(), NDArray::cummax(), FloatComplexNDArray::cummax(), FloatNDArray::cummax(), and intNDArray< T >::cummax().

mx_inline_cummin() [1/6]

template<typename T >

void mx_inline_cummin ( const T *  v, T *  r, octave_idx_type *  ri, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1386 of file mx-inlines.cc.

mx_inline_cummin() [2/6]

template<typename T >

void mx_inline_cummin ( const T *  v, T *  r, octave_idx_type *  ri, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 1327 of file mx-inlines.cc.

mx_inline_cummin() [3/6]

template<typename T >

void mx_inline_cummin	(	const T *	v,
		T *	r,
		octave_idx_type *	ri,
		octave_idx_type	n
	)

Definition at line 1193 of file mx-inlines.cc.

mx_inline_cummin() [4/6]

template<typename T >

void mx_inline_cummin ( const T *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1386 of file mx-inlines.cc.

mx_inline_cummin() [5/6]

template<typename T >

void mx_inline_cummin ( const T *  v, T *  r, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 1327 of file mx-inlines.cc.

mx_inline_cummin() [6/6]

template<typename T >

void mx_inline_cummin	(	const T *	v,
		T *	r,
		octave_idx_type	n
	)

Definition at line 1193 of file mx-inlines.cc.

Referenced by ComplexNDArray::cummin(), NDArray::cummin(), FloatComplexNDArray::cummin(), FloatNDArray::cummin(), and intNDArray< T >::cummin().

mx_inline_cumprod() [1/3]

template<typename T >

void mx_inline_cumprod ( const T *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 922 of file mx-inlines.cc.

mx_inline_cumprod() [2/3]

template<typename T >

void mx_inline_cumprod ( const T *  v, T *  r, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 892 of file mx-inlines.cc.

mx_inline_cumprod() [3/3]

template<typename T >

void mx_inline_cumprod ( const T *  v, T *  r, octave_idx_type  n  )

inline

Definition at line 868 of file mx-inlines.cc.

Referenced by ComplexNDArray::cumprod(), NDArray::cumprod(), FloatComplexNDArray::cumprod(), and FloatNDArray::cumprod().

mx_inline_cumsum() [1/3]

template<typename T >

void mx_inline_cumsum ( const T *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 921 of file mx-inlines.cc.

mx_inline_cumsum() [2/3]

template<typename T >

void mx_inline_cumsum ( const T *  v, T *  r, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 891 of file mx-inlines.cc.

mx_inline_cumsum() [3/3]

template<typename T >

void mx_inline_cumsum ( const T *  v, T *  r, octave_idx_type  n  )

inline

Definition at line 867 of file mx-inlines.cc.

Referenced by intNDArray< T >::cumsum(), ComplexNDArray::cumsum(), NDArray::cumsum(), FloatComplexNDArray::cumsum(), and FloatNDArray::cumsum().

mx_inline_diff() [1/3]

template<typename T >

void mx_inline_diff ( const T *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u, octave_idx_type  order  )

inline

Definition at line 1472 of file mx-inlines.cc.

mx_inline_diff() [2/3]

template<typename T >

void mx_inline_diff	(	const T *	v,
		T *	r,
		octave_idx_type	m,
		octave_idx_type	n,
		octave_idx_type	order
	)

Definition at line 1431 of file mx-inlines.cc.

mx_inline_diff() [3/3]

template<typename T >

void mx_inline_diff	(	const T *	v,
		T *	r,
		octave_idx_type	n,
		octave_idx_type	order
	)

Definition at line 1390 of file mx-inlines.cc.

References dif(), n, OCTAVE_LOCAL_BUFFER, and r.

Referenced by ComplexNDArray::diff(), NDArray::diff(), FloatComplexNDArray::diff(), FloatNDArray::diff(), and intNDArray< T >::diff().

mx_inline_div() [1/3]

template<typename R , typename X , typename Y >

void mx_inline_div ( size_t  n, R *  r, const X *  x, const Y *  y  )

inline

Definition at line 110 of file mx-inlines.cc.

mx_inline_div() [2/3]

template<typename R , typename X , typename Y >

void mx_inline_div ( size_t  n, R *  r, const X *  x, Y  y  )

inline

Definition at line 110 of file mx-inlines.cc.

mx_inline_div() [3/3]

template<typename R , typename X , typename Y >

void mx_inline_div ( size_t  n, R *  r, X  x, const Y *  y  )

inline

Definition at line 110 of file mx-inlines.cc.

mx_inline_div2() [1/2]

template<typename R , typename X >

void mx_inline_div2 ( size_t  n, R *  r, const X *  x  )

inline

Definition at line 129 of file mx-inlines.cc.

Referenced by operator/=(), and quotient_eq().

mx_inline_div2() [2/2]

template<typename R , typename X >

void mx_inline_div2 ( size_t  n, R *  r, X  x  )

inline

Definition at line 129 of file mx-inlines.cc.

mx_inline_dprod()

template<typename T >

void mx_inline_dprod ( const T *  v, typename subst_template_param< std::complex, T, double >::type *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 848 of file mx-inlines.cc.

Referenced by FloatComplexNDArray::dprod(), and FloatNDArray::dprod().

mx_inline_dsum()

template<typename T >

void mx_inline_dsum ( const T *  v, typename subst_template_param< std::complex, T, double >::type *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 845 of file mx-inlines.cc.

Referenced by intNDArray< T >::dsum(), FloatComplexNDArray::dsum(), and FloatNDArray::dsum().

mx_inline_eq() [1/3]

template<typename X , typename Y >

void mx_inline_eq ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 155 of file mx-inlines.cc.

mx_inline_eq() [2/3]

template<typename X , typename Y >

void mx_inline_eq ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 155 of file mx-inlines.cc.

mx_inline_eq() [3/3]

template<typename X , typename Y >

void mx_inline_eq ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 155 of file mx-inlines.cc.

mx_inline_equal()

template<typename T1 , typename T2 >

bool mx_inline_equal ( size_t  n, const T1 *  x, const T2 *  y  )

inline

Definition at line 570 of file mx-inlines.cc.

References n, and x.

Referenced by boolMatrix::operator==(), charMatrix::operator==(), ColumnVector::operator==(), ComplexColumnVector::operator==(), ComplexDiagMatrix::operator==(), ComplexMatrix::operator==(), ComplexRowVector::operator==(), DiagMatrix::operator==(), FloatColumnVector::operator==(), FloatComplexColumnVector::operator==(), FloatComplexDiagMatrix::operator==(), FloatComplexMatrix::operator==(), FloatComplexRowVector::operator==(), FloatDiagMatrix::operator==(), FloatMatrix::operator==(), FloatRowVector::operator==(), Matrix::operator==(), and RowVector::operator==().

mx_inline_fill()

template<typename R , typename S >

void mx_inline_fill ( size_t  n, R *  r, S  s  )

inline

Definition at line 47 of file mx-inlines.cc.

References n, and r.

mx_inline_ge() [1/3]

template<typename X , typename Y >

void mx_inline_ge ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 154 of file mx-inlines.cc.

mx_inline_ge() [2/3]

template<typename X , typename Y >

void mx_inline_ge ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 154 of file mx-inlines.cc.

mx_inline_ge() [3/3]

template<typename X , typename Y >

void mx_inline_ge ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 154 of file mx-inlines.cc.

mx_inline_gt() [1/3]

template<typename X , typename Y >

void mx_inline_gt ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 153 of file mx-inlines.cc.

mx_inline_gt() [2/3]

template<typename X , typename Y >

void mx_inline_gt ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 153 of file mx-inlines.cc.

mx_inline_gt() [3/3]

template<typename X , typename Y >

void mx_inline_gt ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 153 of file mx-inlines.cc.

mx_inline_imag()

template<typename T >

void mx_inline_imag ( size_t  n, T *  r, const std::complex< T > *  x  )

inline

Definition at line 328 of file mx-inlines.cc.

References imag(), n, r, and x.

mx_inline_iszero()

template<typename X >

void mx_inline_iszero ( size_t  n, bool *  r, const X *  x  )

inline

Definition at line 71 of file mx-inlines.cc.

References n, r, and x.

mx_inline_le() [1/3]

template<typename X , typename Y >

void mx_inline_le ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 152 of file mx-inlines.cc.

mx_inline_le() [2/3]

template<typename X , typename Y >

void mx_inline_le ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 152 of file mx-inlines.cc.

mx_inline_le() [3/3]

template<typename X , typename Y >

void mx_inline_le ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 152 of file mx-inlines.cc.

mx_inline_lt() [1/3]

template<typename X , typename Y >

void mx_inline_lt ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 151 of file mx-inlines.cc.

mx_inline_lt() [2/3]

template<typename X , typename Y >

void mx_inline_lt ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 151 of file mx-inlines.cc.

mx_inline_lt() [3/3]

template<typename X , typename Y >

void mx_inline_lt ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 151 of file mx-inlines.cc.

mx_inline_map()

template<typename R , typename X , R fun>

void mx_inline_map ( size_t  n, R *  r, const X *  x  )

inline

Definition at line 445 of file mx-inlines.cc.

References n, r, and x.

mx_inline_max() [1/6]

template<typename T >

void mx_inline_max ( const T *  v, T *  r, octave_idx_type *  ri, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1123 of file mx-inlines.cc.

mx_inline_max() [2/6]

template<typename T >

void mx_inline_max ( const T *  v, T *  r, octave_idx_type *  ri, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 1065 of file mx-inlines.cc.

mx_inline_max() [3/6]

template<typename T >

void mx_inline_max	(	const T *	v,
		T *	r,
		octave_idx_type *	ri,
		octave_idx_type	n
	)

Definition at line 972 of file mx-inlines.cc.

mx_inline_max() [4/6]

template<typename T >

void mx_inline_max ( const T *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1123 of file mx-inlines.cc.

mx_inline_max() [5/6]

template<typename T >

void mx_inline_max ( const T *  v, T *  r, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 1065 of file mx-inlines.cc.

mx_inline_max() [6/6]

template<typename T >

void mx_inline_max	(	const T *	v,
		T *	r,
		octave_idx_type	n
	)

Definition at line 972 of file mx-inlines.cc.

Referenced by charNDArray::max(), ComplexNDArray::max(), NDArray::max(), FloatComplexNDArray::max(), FloatNDArray::max(), and intNDArray< T >::max().

mx_inline_min() [1/6]

template<typename T >

void mx_inline_min ( const T *  v, T *  r, octave_idx_type *  ri, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1122 of file mx-inlines.cc.

mx_inline_min() [2/6]

template<typename T >

void mx_inline_min ( const T *  v, T *  r, octave_idx_type *  ri, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 1064 of file mx-inlines.cc.

mx_inline_min() [3/6]

template<typename T >

void mx_inline_min	(	const T *	v,
		T *	r,
		octave_idx_type *	ri,
		octave_idx_type	n
	)

Definition at line 971 of file mx-inlines.cc.

mx_inline_min() [4/6]

template<typename T >

void mx_inline_min ( const T *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1122 of file mx-inlines.cc.

mx_inline_min() [5/6]

template<typename T >

void mx_inline_min ( const T *  v, T *  r, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 1064 of file mx-inlines.cc.

mx_inline_min() [6/6]

template<typename T >

void mx_inline_min	(	const T *	v,
		T *	r,
		octave_idx_type	n
	)

Definition at line 971 of file mx-inlines.cc.

Referenced by charNDArray::min(), ComplexNDArray::min(), NDArray::min(), FloatComplexNDArray::min(), FloatNDArray::min(), and intNDArray< T >::min().

mx_inline_mul() [1/3]

template<typename R , typename X , typename Y >

void mx_inline_mul ( size_t  n, R *  r, const X *  x, const Y *  y  )

inline

Definition at line 109 of file mx-inlines.cc.

Referenced by kron().

mx_inline_mul() [2/3]

template<typename R , typename X , typename Y >

void mx_inline_mul ( size_t  n, R *  r, const X *  x, Y  y  )

inline

Definition at line 109 of file mx-inlines.cc.

mx_inline_mul() [3/3]

template<typename R , typename X , typename Y >

void mx_inline_mul ( size_t  n, R *  r, X  x, const Y *  y  )

inline

Definition at line 109 of file mx-inlines.cc.

mx_inline_mul2() [1/2]

template<typename R , typename X >

void mx_inline_mul2 ( size_t  n, R *  r, const X *  x  )

inline

Definition at line 128 of file mx-inlines.cc.

Referenced by operator*=(), and product_eq().

mx_inline_mul2() [2/2]

template<typename R , typename X >

void mx_inline_mul2 ( size_t  n, R *  r, X  x  )

inline

Definition at line 128 of file mx-inlines.cc.

mx_inline_ne() [1/3]

template<typename X , typename Y >

void mx_inline_ne ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 156 of file mx-inlines.cc.

mx_inline_ne() [2/3]

template<typename X , typename Y >

void mx_inline_ne ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 156 of file mx-inlines.cc.

mx_inline_ne() [3/3]

template<typename X , typename Y >

void mx_inline_ne ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 156 of file mx-inlines.cc.

mx_inline_not()

template<typename X >

void mx_inline_not	(	size_t	n,
		bool *	r,
		const X *	x
	)

Definition at line 181 of file mx-inlines.cc.

References logical_value(), n, r, and x.

Referenced by boolNDArray::operator!(), ComplexNDArray::operator!(), NDArray::operator!(), FloatComplexNDArray::operator!(), and FloatNDArray::operator!().

mx_inline_not2()

void mx_inline_not2 ( size_t  n, bool *  r  )

inline

Definition at line 187 of file mx-inlines.cc.

References n, and r.

Referenced by boolNDArray::invert().

mx_inline_not_and() [1/3]

template<typename X , typename Y >

void mx_inline_not_and ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 218 of file mx-inlines.cc.

mx_inline_not_and() [2/3]

template<typename X , typename Y >

void mx_inline_not_and ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 218 of file mx-inlines.cc.

mx_inline_not_and() [3/3]

template<typename X , typename Y >

void mx_inline_not_and ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 218 of file mx-inlines.cc.

mx_inline_not_or() [1/3]

template<typename X , typename Y >

void mx_inline_not_or ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 219 of file mx-inlines.cc.

mx_inline_not_or() [2/3]

template<typename X , typename Y >

void mx_inline_not_or ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 219 of file mx-inlines.cc.

mx_inline_not_or() [3/3]

template<typename X , typename Y >

void mx_inline_not_or ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 219 of file mx-inlines.cc.

mx_inline_notzero()

template<typename X >

void mx_inline_notzero ( size_t  n, bool *  r, const X *  x  )

inline

Definition at line 80 of file mx-inlines.cc.

References n, r, and x.

mx_inline_or() [1/3]

template<typename X , typename Y >

void mx_inline_or ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 217 of file mx-inlines.cc.

mx_inline_or() [2/3]

template<typename X , typename Y >

void mx_inline_or ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 217 of file mx-inlines.cc.

mx_inline_or() [3/3]

template<typename X , typename Y >

void mx_inline_or ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 217 of file mx-inlines.cc.

mx_inline_or2() [1/2]

template<typename X >

void mx_inline_or2 ( size_t  n, bool *  r, const X *  x  )

inline

Definition at line 241 of file mx-inlines.cc.

References logical_value(), n, r, and x.

Referenced by mx_el_or_assign().

mx_inline_or2() [2/2]

template<typename X >

void mx_inline_or2 ( size_t  n, bool *  r, X  x  )

inline

Definition at line 249 of file mx-inlines.cc.

References n, r, and x.

mx_inline_or_not() [1/3]

template<typename X , typename Y >

void mx_inline_or_not ( size_t  n, bool *  r, const X *  x, const Y *  y  )

inline

Definition at line 221 of file mx-inlines.cc.

mx_inline_or_not() [2/3]

template<typename X , typename Y >

void mx_inline_or_not ( size_t  n, bool *  r, const X *  x, Y  y  )

inline

Definition at line 221 of file mx-inlines.cc.

mx_inline_or_not() [3/3]

template<typename X , typename Y >

void mx_inline_or_not ( size_t  n, bool *  r, X  x, const Y *  y  )

inline

Definition at line 221 of file mx-inlines.cc.

mx_inline_pow() [1/3]

template<typename R , typename X , typename Y >

void mx_inline_pow ( size_t  n, R *  r, const X *  x, const Y *  y  )

inline

Definition at line 414 of file mx-inlines.cc.

References n, pow(), r, and x.

mx_inline_pow() [2/3]

template<typename R , typename X , typename Y >

void mx_inline_pow ( size_t  n, R *  r, const X *  x, Y  y  )

inline

Definition at line 424 of file mx-inlines.cc.

References n, pow(), r, and x.

mx_inline_pow() [3/3]

template<typename R , typename X , typename Y >

void mx_inline_pow ( size_t  n, R *  r, X  x, const Y *  y  )

inline

Definition at line 434 of file mx-inlines.cc.

References n, pow(), r, and x.

mx_inline_prod()

template<typename T >

void mx_inline_prod ( const T *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 847 of file mx-inlines.cc.

Referenced by intNDArray< T >::prod(), ComplexNDArray::prod(), NDArray::prod(), FloatComplexNDArray::prod(), and FloatNDArray::prod().

mx_inline_real()

template<typename T >

void mx_inline_real ( size_t  n, T *  r, const std::complex< T > *  x  )

inline

Definition at line 321 of file mx-inlines.cc.

References n, r, real(), and x.

mx_inline_sub() [1/3]

template<typename R , typename X , typename Y >

void mx_inline_sub ( size_t  n, R *  r, const X *  x, const Y *  y  )

inline

Definition at line 108 of file mx-inlines.cc.

Referenced by Sparse< T >::delete_elements(), and Sparse< T >::index().

mx_inline_sub() [2/3]

template<typename R , typename X , typename Y >

void mx_inline_sub ( size_t  n, R *  r, const X *  x, Y  y  )

inline

Definition at line 108 of file mx-inlines.cc.

mx_inline_sub() [3/3]

template<typename R , typename X , typename Y >

void mx_inline_sub ( size_t  n, R *  r, X  x, const Y *  y  )

inline

Definition at line 108 of file mx-inlines.cc.

mx_inline_sub2() [1/2]

template<typename R , typename X >

void mx_inline_sub2 ( size_t  n, R *  r, const X *  x  )

inline

Definition at line 127 of file mx-inlines.cc.

Referenced by ComplexColumnVector::operator-=(), FloatComplexColumnVector::operator-=(), FloatComplexMatrix::operator-=(), FloatComplexRowVector::operator-=(), ComplexMatrix::operator-=(), ComplexRowVector::operator-=(), and operator-=().

mx_inline_sub2() [2/2]

template<typename R , typename X >

void mx_inline_sub2 ( size_t  n, R *  r, X  x  )

inline

Definition at line 127 of file mx-inlines.cc.

mx_inline_sum() [1/2]

template<typename T >

T mx_inline_sum ( const T *  v, octave_idx_type  n  )

inline

Definition at line 752 of file mx-inlines.cc.

Referenced by intNDArray< T >::sum(), ComplexNDArray::sum(), NDArray::sum(), FloatComplexNDArray::sum(), and FloatNDArray::sum().

mx_inline_sum() [2/2]

template<typename T >

void mx_inline_sum ( const T *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 844 of file mx-inlines.cc.

mx_inline_sumsq() [1/4]

template<typename T >

void mx_inline_sumsq ( const std::complex< T > *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 850 of file mx-inlines.cc.

mx_inline_sumsq() [2/4]

template<typename T >

T mx_inline_sumsq ( const T *  v, octave_idx_type  n  )

inline

Definition at line 755 of file mx-inlines.cc.

Referenced by ComplexNDArray::sumsq(), NDArray::sumsq(), FloatComplexNDArray::sumsq(), and FloatNDArray::sumsq().

mx_inline_sumsq() [3/4]

template<typename T >

void mx_inline_sumsq ( const T *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 849 of file mx-inlines.cc.

mx_inline_sumsq() [4/4]

template<typename T >

void mx_inline_sumsq ( const T *  v, T *  r, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 776 of file mx-inlines.cc.

mx_inline_uminus()

template<typename R , typename X >

void mx_inline_uminus ( size_t  n, R *  r, const X *  x  )

inline

Definition at line 55 of file mx-inlines.cc.

References n, r, and x.

Referenced by operator-().

mx_inline_uminus2()

template<typename R >

void mx_inline_uminus2 ( size_t  n, R *  r  )

inline

Definition at line 63 of file mx-inlines.cc.

References n, and r.

Referenced by MArray< T >::changesign().

mx_inline_xmax() [1/3]

template<typename T >

void mx_inline_xmax ( size_t  n, T *  r, const T *  x, const T *  y  )

inline

Definition at line 360 of file mx-inlines.cc.

References octave::math::max(), n, r, and x.

Referenced by max().

mx_inline_xmax() [2/3]

template<typename T >

void mx_inline_xmax ( size_t  n, T *  r, const T *  x, T  y  )

inline

Definition at line 368 of file mx-inlines.cc.

References octave::math::max(), n, r, and x.

mx_inline_xmax() [3/3]

template<typename T >

void mx_inline_xmax ( size_t  n, T *  r, T  x, const T *  y  )

inline

Definition at line 376 of file mx-inlines.cc.

References octave::math::max(), n, r, and x.

mx_inline_xmax< double >() [1/2]

template<>

void mx_inline_xmax< double > ( size_t  n, double *  r, const double *  x, double  y  )

inline

Definition at line 404 of file mx-inlines.cc.

mx_inline_xmax< double >() [2/2]

template<>

void mx_inline_xmax< double > ( size_t  n, double *  r, double  x, const double *  y  )

inline

Definition at line 404 of file mx-inlines.cc.

mx_inline_xmax< float >() [1/2]

template<>

void mx_inline_xmax< float > ( size_t  n, float *  r, const float *  x, float  y  )

inline

Definition at line 406 of file mx-inlines.cc.

mx_inline_xmax< float >() [2/2]

template<>

void mx_inline_xmax< float > ( size_t  n, float *  r, float  x, const float *  y  )

inline

Definition at line 406 of file mx-inlines.cc.

mx_inline_xmin() [1/3]

template<typename T >

void mx_inline_xmin ( size_t  n, T *  r, const T *  x, const T *  y  )

inline

Definition at line 336 of file mx-inlines.cc.

References octave::math::min(), n, r, and x.

Referenced by min().

mx_inline_xmin() [2/3]

template<typename T >

void mx_inline_xmin ( size_t  n, T *  r, const T *  x, T  y  )

inline

Definition at line 344 of file mx-inlines.cc.

References octave::math::min(), n, r, and x.

mx_inline_xmin() [3/3]

template<typename T >

void mx_inline_xmin ( size_t  n, T *  r, T  x, const T *  y  )

inline

Definition at line 352 of file mx-inlines.cc.

References octave::math::min(), n, r, and x.

mx_inline_xmin< double >() [1/2]

template<>

void mx_inline_xmin< double > ( size_t  n, double *  r, const double *  x, double  y  )

inline

Definition at line 403 of file mx-inlines.cc.

mx_inline_xmin< double >() [2/2]

template<>

void mx_inline_xmin< double > ( size_t  n, double *  r, double  x, const double *  y  )

inline

Definition at line 403 of file mx-inlines.cc.

mx_inline_xmin< float >() [1/2]

template<>

void mx_inline_xmin< float > ( size_t  n, float *  r, const float *  x, float  y  )

inline

Definition at line 405 of file mx-inlines.cc.

mx_inline_xmin< float >() [2/2]

template<>

void mx_inline_xmin< float > ( size_t  n, float *  r, float  x, const float *  y  )

inline

Definition at line 405 of file mx-inlines.cc.

mx_inline_xsum() [1/3]

template<typename T >

T mx_inline_xsum ( const T *  v, octave_idx_type  n  )

inline

Definition at line 1698 of file mx-inlines.cc.

Referenced by ComplexNDArray::xsum(), and NDArray::xsum().

mx_inline_xsum() [2/3]

template<typename T >

void mx_inline_xsum ( const T *  v, T *  r, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1729 of file mx-inlines.cc.

mx_inline_xsum() [3/3]

template<typename T >

void mx_inline_xsum ( const T *  v, T *  r, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 1710 of file mx-inlines.cc.

OOP_RED_FCN() [1/4]

OOP_RED_FCN	(	mx_inline_all	,
		T	,
		bool	,
		OP_RED_ALLC	,
		true
	)		const

OOP_RED_FCN() [2/4]

OOP_RED_FCN	(	mx_inline_dsum	,
		T	,
		typename subst_template_param< std::complex, T, double >::type	,
		op_dble_sum	,
		0.	0
	)		const

OOP_RED_FCN() [3/4]

OOP_RED_FCN	(	mx_inline_prod	,
		T	,
		T	,
		OP_RED_PROD	,
		1
	)

Definition at line 753 of file mx-inlines.cc.

OOP_RED_FCN() [4/4]

OOP_RED_FCN	(	mx_inline_sumsq	,
		std::complex< T >	,
		T	,
		OP_RED_SUMSQC	,
		0
	)		const

OOP_RED_FCN2() [1/4]

OOP_RED_FCN2	(	mx_inline_all_r	,
		T	,
		bool	,
		OP_RED_ALLR	,
		true
	)		const

OOP_RED_FCN2() [2/4]

OOP_RED_FCN2	(	mx_inline_dsum	,
		T	,
		typename subst_template_param< std::complex, T, double >::type	,
		op_dble_sum	,
		0.	0
	)		const

OOP_RED_FCN2() [3/4]

OOP_RED_FCN2	(	mx_inline_prod	,
		T	,
		T	,
		OP_RED_PROD	,
		1
	)		const

OOP_RED_FCN2() [4/4]

OOP_RED_FCN2	(	mx_inline_sumsq	,
		std::complex< T >	,
		T	,
		OP_RED_SUMSQC	,
		0
	)		const

op_dble_prod() [1/3]

void op_dble_prod ( Complex &  ac, const FloatComplex &  el  )

inline

Definition at line 687 of file mx-inlines.cc.

References ac.

op_dble_prod() [2/3]

template<typename T >

void op_dble_prod ( double &  ac, const octave_int< T > &  el  )

inline

Definition at line 694 of file mx-inlines.cc.

References ac, and octave_int< T >::double_value().

op_dble_prod() [3/3]

void op_dble_prod ( double &  ac, float  el  )

inline

Definition at line 680 of file mx-inlines.cc.

References ac.

op_dble_sum() [1/3]

void op_dble_sum ( Complex &  ac, const FloatComplex &  el  )

inline

Definition at line 707 of file mx-inlines.cc.

References ac.

op_dble_sum() [2/3]

template<typename T >

void op_dble_sum ( double &  ac, const octave_int< T > &  el  )

inline

Definition at line 714 of file mx-inlines.cc.

References ac, and octave_int< T >::double_value().

op_dble_sum() [3/3]

void op_dble_sum ( double &  ac, float  el  )

inline

Definition at line 700 of file mx-inlines.cc.

References ac.

twosum_accum()

template<typename T >

void twosum_accum ( T &  s, T &  e, const T &  x  )

inline

Definition at line 1686 of file mx-inlines.cc.

xis_false() [1/6]

bool xis_false ( const Complex &  x )

inline

Definition at line 657 of file mx-inlines.cc.

References x.

xis_false() [2/6]

bool xis_false ( const FloatComplex &  x )

inline

Definition at line 669 of file mx-inlines.cc.

References x.

xis_false() [3/6]

template<typename T >

bool xis_false ( const octave_int< T > &  x )

inline

Definition at line 619 of file mx-inlines.cc.

References x.

xis_false() [4/6]

bool xis_false ( double  x )

inline

Definition at line 632 of file mx-inlines.cc.

References x.

xis_false() [5/6]

bool xis_false ( float  x )

inline

Definition at line 644 of file mx-inlines.cc.

References x.

xis_false() [6/6]

template<typename T >

bool xis_false ( T  x )

inline

Definition at line 604 of file mx-inlines.cc.

References x.

xis_true() [1/6]

bool xis_true ( const Complex &  x )

inline

Definition at line 651 of file mx-inlines.cc.

References octave::math::isnan(), and x.

xis_true() [2/6]

bool xis_true ( const FloatComplex &  x )

inline

Definition at line 663 of file mx-inlines.cc.

References octave::math::isnan(), and x.

xis_true() [3/6]

template<typename T >

bool xis_true ( const octave_int< T > &  x )

inline

Definition at line 612 of file mx-inlines.cc.

References x.

xis_true() [4/6]

bool xis_true ( double  x )

inline

Definition at line 626 of file mx-inlines.cc.

References octave::math::isnan(), and x.

xis_true() [5/6]

bool xis_true ( float  x )

inline

Definition at line 638 of file mx-inlines.cc.

References octave::math::isnan(), and x.

xis_true() [6/6]

template<typename T >

bool xis_true ( T  x )

inline

Definition at line 597 of file mx-inlines.cc.

References x.

Variable Documentation

ac

return ac

Definition at line 753 of file mx-inlines.cc.

Referenced by octave::math::sparse_chol< chol_type >::sparse_chol_rep< chol_type >::init(), op_dble_prod(), and op_dble_sum().

continue

else continue

Definition at line 756 of file mx-inlines.cc.

iact

octave_idx_type* iact = octave_local_buffer_iact .get ()

Definition at line 816 of file mx-inlines.cc.

m

bool octave_idx_type m

Definition at line 773 of file mx-inlines.cc.

Referenced by Cell::Cell(), octave_class::exemplar_info::exemplar_info(), octave::math::gsvd< T >::gsvd(), mxArray_matlab::mxArray_matlab(), mxArray_number::mxArray_number(), octave_map::octave_map(), octave_scalar_map::octave_scalar_map(), octave::math::svd< T >::svd(), octave::bp_table::add_breakpoint(), octave::set_path_dialog::add_dir_common(), octave::load_path::package_info::add_to_method_map(), QtHandles::Canvas::addEventMask(), octave_range::all(), octave_range::any(), any_all_test(), octave_range::as_mxArray(), mxArray_struct::as_octave_value(), property_list::as_struct(), Sparse< T >::assign(), octave::gtk_manager::available_toolkits_list(), rec_permute_helper::blk_trans(), blkmm_internal(), octave_range::bool_array_value(), octave_sparse_matrix::bool_array_value(), cam2xform(), octave::check_access(), check_limit_vals(), check_lu_dims(), check_qr_dims(), Array< octave_value * >::clear(), octave::delimited_stream::clear(), QtHandles::Canvas::clearEventMask(), column_norms(), octave::files_dock_widget::contextmenu_copy_selection(), octave::files_dock_widget::contextmenu_delete(), octave::files_dock_widget::contextmenu_findfiles(), octave::files_dock_widget::contextmenu_load(), octave::files_dock_widget::contextmenu_newdir(), octave::files_dock_widget::contextmenu_newfile(), octave::files_dock_widget::contextmenu_open(), octave::files_dock_widget::contextmenu_open_in_app(), octave::files_dock_widget::contextmenu_open_in_editor(), octave::files_dock_widget::contextmenu_rename(), octave::files_dock_widget::contextmenu_requested(), octave::files_dock_widget::contextmenu_run(), octave_stdiostream::create(), octave_zstdiostream::create(), decode_subscripts(), default_axes_outerposition(), default_axes_position(), default_axes_tick(), default_axes_ticklength(), default_axes_view(), default_figure_paperposition(), default_figure_papersize(), default_figure_position(), default_image_cdata(), default_light_position(), default_lim(), default_patch_faces(), default_patch_vertices(), default_patch_xdata(), default_patch_ydata(), default_surface_xdata(), default_surface_ydata(), default_surface_zdata(), qr< T >::delete_col(), Array< T >::delete_elements(), qr< T >::delete_row(), Cell::diag(), octave_base_matrix< MT >::diag(), octave_complex::diag(), octave_complex_matrix::diag(), octave_float_scalar::diag(), octave_float_complex::diag(), octave_float_complex_matrix::diag(), octave_float_matrix::diag(), octave_range::diag(), octave_matrix::diag(), octave_scalar::diag(), octave_value::diag(), Array< T >::diag(), boolNDArray::diag(), charNDArray::diag(), ComplexMatrix::diag(), ComplexNDArray::diag(), Matrix::diag(), NDArray::diag(), FloatComplexMatrix::diag(), FloatComplexNDArray::diag(), FloatMatrix::diag(), FloatNDArray::diag(), intNDArray< T >::diag(), dmdm_div_impl(), dmdm_leftdiv_impl(), dmm_leftdiv_impl(), dmperm_internal(), dmsolve(), dmsolve_extract(), do_bitpack(), do_bitunpack(), do_blkmm(), do_class_concat(), octave::tree_jit::do_open_new_module(), do_rand(), color_property::do_set(), do_tril(), do_triu(), draw(), octave::opengl_renderer::draw_patch(), octave::opengl_renderer::draw_text_background(), octave::fcn_info::fcn_info_rep::dump(), octave::symbol_record::symbol_record_rep::dump(), octave::symbol_scope_rep::dump(), octave::symbol_table::dump(), octave_base_value::dump(), octave_user_code::dump(), octave_user_function::dump(), octave::scalar_struct_model::edit_display(), octave::vector_struct_model::edit_display(), EigsComplexNonSymmetricMatrix(), EigsComplexNonSymmetricMatrixShift(), EigsRealNonSymmetricMatrix(), EigsRealNonSymmetricMatrixShift(), EigsRealSymmetricMatrix(), EigsRealSymmetricMatrixShift(), octave::math::ellipj(), QtHandles::BaseControl::eventFilter(), QtHandles::ListBoxControl::eventFilter(), QtHandles::ButtonGroup::eventFilter(), QtHandles::Panel::eventFilter(), QtHandles::Table::eventFilter(), extract_tm(), F__fieldnames__(), F__voronoi__(), Fbitshift(), Fchol(), Fcholinv(), Fclass(), Fdbstatus(), Fdet(), Fdiag(), Fdot(), Fellipj(), Ferror(), Fget(), find_config_info(), octave::load_path::package_info::find_method(), octave::base_parser::finish_matrix(), Finv(), Fisfield(), octave::float_identity_matrix(), Flu(), Fmatrix_type(), Fordschur(), qr< T >::form(), Fpinv(), Fqr(), Fquadcc(), Fqz(), Frandperm(), Frats(), Frcond(), Fresize(), Frmfield(), FSIG(), Fsize(), Fspalloc(), Fsparse(), Fstruct2cell(), Fterminal_size(), Funame(), Fwarning(), octave_sort< T >::gallop_left(), octave_sort< T >::gallop_right(), svd< T >::gesdd(), svd< T >::gesvd(), get_array_limits(), octave::tree_evaluator::get_autoload_map(), get_blkmm_dims(), base_properties::get_dynamic(), octave::profiler::get_flat(), octave::profiler::get_hierarchical(), array_property::get_limits(), get_object_dims(), get_red_dims(), octave::files_dock_widget::get_selected_items_info(), octave::workspace_view::get_var_name(), Vt102Emulation::getMode(), Screen::getMode(), gsvd< T >::ggsvd(), octave::opengl_functions::glMultMatrixd(), glpk(), octave::scalar_struct_model::header_data(), octave::vector_struct_model::header_data(), hex2num(), higham(), identity_matrix(), octave::identity_matrix(), Sparse< T >::index(), octave::internal_fcn_handle::info(), octave::simple_fcn_handle::info(), octave::scoped_fcn_handle::info(), octave::nested_fcn_handle::info(), octave::class_simple_fcn_handle::info(), octave::anonymous_fcn_handle::info(), qr< T >::init(), qrp< T >::init(), octave::opengl_selector::init_marker(), octave::opengl_renderer::init_marker(), qr< T >::insert_col(), qr< T >::insert_row(), install_dld_function(), intfield(), octave::math::sparse_chol< chol_type >::inverse(), octave_range::is_true(), isvector(), octave::find_files_dialog::item_double_clicked(), octave::math::sparse_chol< chol_type >::L(), lin_interpn(), linspace(), octave_class::load_ascii(), octave_struct::load_ascii(), octave_scalar_struct::load_ascii(), octave_bool_matrix::load_binary(), octave_sparse_bool_matrix::load_binary(), octave_class::load_binary(), octave_complex_diag_matrix::load_binary(), octave_complex_matrix::load_binary(), octave_sparse_complex_matrix::load_binary(), octave_float_complex_diag_matrix::load_binary(), octave_float_complex_matrix::load_binary(), octave_float_diag_matrix::load_binary(), octave_float_matrix::load_binary(), octave_perm_matrix::load_binary(), octave_diag_matrix::load_binary(), octave_matrix::load_binary(), octave_sparse_matrix::load_binary(), octave_char_matrix_str::load_binary(), octave_struct::load_binary(), octave_scalar_struct::load_binary(), octave_base_int_matrix< T >::load_binary(), octave_sparse_bool_matrix::load_hdf5(), octave_cell::load_hdf5(), octave_class::load_hdf5(), octave_complex_matrix::load_hdf5(), octave_sparse_complex_matrix::load_hdf5(), octave_float_complex_matrix::load_hdf5(), octave_float_matrix::load_hdf5(), octave_matrix::load_hdf5(), octave_sparse_matrix::load_hdf5(), octave_char_matrix_str::load_hdf5(), octave_struct::load_hdf5(), octave_scalar_struct::load_hdf5(), octave_base_int_matrix< T >::load_hdf5_internal(), octave::gtk_manager::loaded_toolkits_list(), octave::find_files_dialog::look_for_files(), ComplexMatrix::lssolve(), FloatComplexMatrix::lssolve(), FloatMatrix::lssolve(), Matrix::lssolve(), ltsolve(), LuAminusSigmaB(), lusolve(), make_format(), make_idx_args(), make_matrix_format(), octave::make_sig_struct(), Array< T >::map(), octave_bool_matrix::map(), octave_sparse_bool_matrix::map(), octave_bool::map(), octave_char_matrix::map(), octave_uint64_matrix::map(), octave_uint64_scalar::map(), octave_range::map(), octave::map2Cell(), matrix_norm(), max(), max_str_len(), mdm_div_impl(), mexGet(), min(), mk_gr_map(), mk_pw_map(), mk_stat_map(), mk_tm_map(), octave::set_path_dialog::move_dir_bottom(), octave::set_path_dialog::move_dir_down(), octave::set_path_dialog::move_dir_top(), octave::set_path_dialog::move_dir_up(), mxCreateCellMatrix(), mxCreateCharMatrixFromStrings(), mxCreateDoubleMatrix(), mxCreateLogicalMatrix(), mxCreateNumericMatrix(), mxCreateSparse(), mxCreateSparseLogicalMatrix(), mxCreateStructMatrix(), mxCreateUninitNumericMatrix(), mxSetM(), octave::next_power_of_2(), Array< T >::nth_element(), oct_binop_sub(), octave::octave_jit_cast_any_matrix(), octave::octave_jit_cast_matrix_any(), octave::octave_jit_grab_matrix(), octave::octave_jit_print_matrix(), octave::octave_jit_release_matrix(), octave_print_diag_matrix_internal(), octave_print_free(), octave_print_internal(), octave_print_internal_template(), octave_print_matrix_internal(), operator*(), operator<<(), octave::mutex::operator=(), octave_map::operator=(), octave_scalar_map::operator=(), octave::load_path::package_info::overloads(), PermMatrix::pos_power(), PermMatrix::power(), octave::pprsc(), pr_max_internal(), pr_min_internal(), pr_plus_format_matrix(), print_nd_array(), qs_preprocess(), qs_search(), rational_approx(), read_mat5_binary_element(), read_mat5_integer_data(), base_graphics_object::remove_all_listeners(), octave::scalar_struct_model::requires_sub_editor(), octave::vector_struct_model::requires_sub_editor(), octave::struct_model::requires_sub_editor(), Screen::resetMode(), Vt102Emulation::resetMode(), DiagArray2< T >::resize(), octave_user_function::restore_warning_states(), Screen::restoreMode(), Vt102Emulation::restoreMode(), octave::set_path_dialog::rm_dir(), row_norms(), octave_class::save_ascii(), octave_struct::save_ascii(), octave_scalar_struct::save_ascii(), octave_bool_matrix::save_binary(), octave_class::save_binary(), octave_complex_diag_matrix::save_binary(), octave_complex_matrix::save_binary(), octave_float_complex_diag_matrix::save_binary(), octave_float_complex_matrix::save_binary(), octave_float_diag_matrix::save_binary(), octave_float_matrix::save_binary(), octave_diag_matrix::save_binary(), octave_matrix::save_binary(), octave_char_matrix_str::save_binary(), octave_struct::save_binary(), octave_scalar_struct::save_binary(), octave::load_save_system::save_fields(), octave_bool_matrix::save_hdf5(), octave_sparse_bool_matrix::save_hdf5(), octave_class::save_hdf5(), octave_complex_matrix::save_hdf5(), octave_sparse_complex_matrix::save_hdf5(), octave_float_complex_matrix::save_hdf5(), octave_float_matrix::save_hdf5(), octave_matrix::save_hdf5(), octave_sparse_matrix::save_hdf5(), octave_char_matrix_str::save_hdf5(), octave_struct::save_hdf5(), octave_scalar_struct::save_hdf5(), save_mat5_binary_element(), save_mat5_element_length(), save_mat_ascii_data(), save_mat_binary_data(), Screen::saveMode(), Vt102Emulation::saveMode(), lin_scaler::scale(), log_scaler::scale(), neg_log_scaler::scale(), scaler::scale(), scale(), graphics_object::set(), mxArray_matlab::set_m(), mxArray::set_m(), octave::ft_text_renderer::set_mode(), octave::set_sig_struct_field(), QtHandles::Canvas::setEventMask(), Screen::setMode(), Vt102Emulation::setMode(), octave::delimited_stream::setstate(), qr< T >::shift_cols(), Array< T >::sort(), Sparse< T >::sort(), stack_complex_matrix(), octave::find_files_dialog::start_find(), octave::find_files_dialog::stop_find(), stringfield(), octave::scalar_struct_model::subscript_expression(), octave::vector_struct_model::subscript_expression(), svd_matrix_norm(), transform(), translate(), unit_cube(), unstack_complex_matrix(), lu< T >::update(), qr< T >::update(), octave::set_path_dialog::update_model(), lu< T >::update_piv(), utsolve(), octave::scalar_struct_model::value_at(), octave::vector_struct_model::value_at(), octave::struct_model::value_at(), base_graphics_object::values_as_string(), base_graphics_object::values_as_struct(), vector_product(), octave::sys::windows_glob(), write_mat5_array(), write_mat5_integer_data(), xform(), xform_matrix(), xform_scale(), and xform_translate().

n

bool octave_idx_type octave_idx_type n { T ac = 0

Definition at line 753 of file mx-inlines.cc.

Referenced by aepbalance< T >::aepbalance(), Array< T >::ArrayRep::ArrayRep(), Cell::Cell(), charNDArray::charNDArray(), ComplexNDArray::ComplexNDArray(), FloatComplexNDArray::FloatComplexNDArray(), FloatNDArray::FloatNDArray(), octave::math::gsvd< T >::gsvd(), QtHandles::ListBoxControl::ListBoxControl(), mxArray_matlab::mxArray_matlab(), mxArray_sparse::mxArray_sparse(), NDArray::NDArray(), octave_class::octave_class(), octave_fields::octave_fields(), octave_value_list::octave_value_list(), PermMatrix::PermMatrix(), octave::printf_format_list::printf_format_list(), octave::scanf_format_list::scanf_format_list(), Sparse< T >::Sparse(), string_vector::string_vector(), octave::math::svd< T >::svd(), octave::textscan_format_list::textscan_format_list(), octave::tree_index_expression::tree_index_expression(), octave::printf_format_list::~printf_format_list(), octave::scanf_format_list::~scanf_format_list(), octave::textscan_format_list::~textscan_format_list(), mxArray_struct::add_field(), octave::scanf_format_list::all_character_conversions(), all_colon_equiv(), octave::scanf_format_list::all_numeric_conversions(), all_ok(), octave_value_list::all_scalars(), octave_value_list::all_strings_p(), octave_user_function::all_va_args(), dim_vector::alloc(), octave_value_list::any_cell(), any_orig_empty(), octave_value_list::append(), octave::tree_index_expression::append(), array_norm_2(), Array< T >::assign(), Sparse< T >::assign(), octave_base_matrix< MT >::assign(), idx_vector::assign(), octave::lexical_feedback::token_cache::at(), Screen::backTabulate(), octave::call_stack::backtrace_frames(), aepbalance< T >::balancing_matrix(), bitshift(), blkmm_internal(), idx_vector::bloop(), octave::tree_evaluator::breaking(), calc_single_subscript_internal(), calculate_step_vector2d(), calculate_step_vector3d(), mex::calloc(), mxArray::calloc(), mex::calloc_unmarked(), Array< T >::cat(), octave_map::cat(), Sparse< T >::cat(), Cell::cellstr_value(), MArray< double >::changesign(), check_lu_dims(), check_qr_dims(), idx_vector::idx_vector_rep::checkelem(), idx_vector::idx_mask_rep::checkelem(), Array< T >::checkelem(), Sparse< T >::checkelem(), octave_map::checkelem(), idx_vector::checkelem(), octave::chol2inv_internal(), octave::command_history::clean_up_and_save(), ComplexColumnVector::clear(), ComplexRowVector::clear(), ColumnVector::clear(), RowVector::clear(), FloatComplexColumnVector::clear(), FloatColumnVector::clear(), FloatComplexRowVector::clear(), FloatRowVector::clear(), idx_vector::complement(), Sparse< T >::compute_index(), compute_index(), octave::tree_evaluator::continuing(), octave_sort< T >::count_run(), octave_stdiostream::create(), octave_zstdiostream::create(), octave_iprocstream::create(), octave_oprocstream::create(), octave_istream::create(), octave_ostream::create(), octave::jit_index_operation::create_arg_array(), Screen::cursorDown(), Screen::cursorLeft(), Screen::cursorRight(), Screen::cursorUp(), octave::tree_evaluator::dbupdown(), octave::call_stack::dbupdown(), ddasrt_g(), octave::tree_evaluator::debug_frame(), decode_subscripts(), qr< T >::delete_col(), Array< T >::delete_elements(), qr< T >::delete_row(), chol< T >::delete_sym(), Screen::deleteChars(), Screen::deleteLines(), dfopr(), Array< T >::diag(), Sparse< T >::diag(), Cell::diag(), octave_base_matrix< MT >::diag(), octave_complex::diag(), octave_complex_matrix::diag(), octave_float_scalar::diag(), octave_float_complex::diag(), octave_float_complex_matrix::diag(), octave_float_matrix::diag(), octave_range::diag(), octave_matrix::diag(), octave_scalar::diag(), octave_value::diag(), boolNDArray::diag(), charNDArray::diag(), ComplexMatrix::diag(), ComplexNDArray::diag(), Matrix::diag(), NDArray::diag(), FloatComplexMatrix::diag(), FloatComplexNDArray::diag(), FloatMatrix::diag(), FloatNDArray::diag(), intNDArray< T >::diag(), octave_range::dims(), dmdm_div_impl(), dmdm_leftdiv_impl(), dmm_leftdiv_impl(), do_accumarray_minmax(), do_accumarray_minmax_fun(), do_accumarray_sum(), do_accumdim_sum(), do_bitpack(), do_bitunpack(), do_blkmm(), octave_map::do_cat(), do_cellslices_nda(), do_dbstack(), do_dbupdown(), octave::command_editor::do_decode_prompt_string(), do_extended_gcd(), DASPK::do_integrate(), DASSL::do_integrate(), LSODE::do_integrate(), do_linspace(), do_merge(), do_numeric_lookup(), do_permute(), do_rand(), do_rc_map(), do_repelems(), log_scaler::do_scale(), neg_log_scaler::do_scale(), octave::command_history::do_set_size(), octave::do_simple_cellfun(), do_strcmp_fun(), do_tril(), do_triu(), octave::rand::do_vector(), chol< T >::downdate(), downdate(), octave::opengl_renderer::draw_line(), EigsComplexNonSymmetricFunc(), EigsComplexNonSymmetricMatrix(), EigsComplexNonSymmetricMatrixShift(), EigsRealNonSymmetricFunc(), EigsRealNonSymmetricMatrix(), EigsRealNonSymmetricMatrixShift(), EigsRealSymmetricFunc(), EigsRealSymmetricMatrix(), EigsRealSymmetricMatrixShift(), octave_value_list::elem(), Array< T >::elem(), Sparse< T >::elem(), octave_map::elem(), idx_vector::elem(), elem_xpow(), octave::call_stack::element(), octave::math::ellipj(), octave_fields::equal_up_to_order(), Screen::eraseChars(), octave::err_invalid_index(), octave::tree_evaluator::evaluate_end_expression(), octave::tree_multi_assignment::evaluate_n(), octave::tree_index_expression::evaluate_n(), idx_vector::idx_colon_rep::extent(), idx_vector::idx_range_rep::extent(), idx_vector::idx_scalar_rep::extent(), idx_vector::idx_vector_rep::extent(), idx_vector::idx_mask_rep::extent(), idx_vector::extent(), ComplexRowVector::extract_n(), RowVector::extract_n(), FloatComplexRowVector::extract_n(), FloatRowVector::extract_n(), ComplexColumnVector::extract_n(), ColumnVector::extract_n(), FloatComplexColumnVector::extract_n(), FloatColumnVector::extract_n(), PermMatrix::eye(), F__accumarray_sum__(), F__accumdim_sum__(), F__delaunayn__(), F__dsearchn__(), F__eigs__(), F__fltk_uigetfile__(), F__ftp_dir__(), F__ftp_mget__(), F__get__(), F__lin_interpn__(), F__magick_read__(), F__version_info__(), Faddeeva_w(), octave_map::fast_elem_extract(), octave_base_diag< DMT, MT >::fast_elem_extract(), octave_base_matrix< MT >::fast_elem_extract(), octave_base_scalar< ST >::fast_elem_extract(), octave_base_sparse< T >::fast_elem_extract(), octave_lazy_index::fast_elem_extract(), octave_perm_matrix::fast_elem_extract(), octave_range::fast_elem_extract(), octave_struct::fast_elem_extract(), octave_value::fast_elem_extract(), octave_map::fast_elem_insert(), octave_base_matrix< MT >::fast_elem_insert(), octave_struct::fast_elem_insert(), octave_value::fast_elem_insert(), Fbitshift(), Fcellslices(), Fchar(), Fchol(), Fcholdelete(), Fcholinsert(), Fcholshift(), Fcholupdate(), Fdblist(), Fdbstep(), Fdiag(), Fdlmread(), Fdot(), Fget(), octave_fields::fieldnames(), octave::main_window::file_remove_proxy(), idx_vector::fill(), octave::cdef_object_array::fill_empty_values(), fill_exif_floats(), fill_exif_ints(), Array< T >::find(), find_nonzero_elem_idx(), octave::scanf_format_list::finish_conversion(), octave::textscan_format_list::finish_conversion(), Fisfield(), Fisindex(), octave::float_identity_matrix(), octave::rand::float_vector(), Flu(), Fnth_element(), Fordschur(), qr< T >::form(), octave::math::fortran_psifn< double >(), octave::math::fortran_psifn< float >(), ComplexNDArray::fourier(), NDArray::fourier(), FloatComplexNDArray::fourier(), FloatNDArray::fourier(), Fquadcc(), Frandperm(), Frats(), freeze(), Freset(), QtHandles::Utils::fromStringVector(), Fset(), Fspalloc(), Fsparse(), Fsqrtm(), Fstrncmp(), Fstrncmpi(), Fstrvcat(), Fsymbfact(), octave::profiler::stats::function_set_value(), octave_sort< T >::gallop_left(), octave_sort< T >::gallop_right(), svd< T >::gesdd(), svd< T >::gesvd(), get_array_limits(), get_blkmm_dims(), get_children_limits(), get_dim_vector(), octave::get_dimensions(), octave::get_dispatch_type(), get_elt_idx(), octave::command_history::get_entry(), octave::load_path::get_file_list(), octave::profiler::get_flat(), octave::profiler::tree_node::get_hierarchical(), octave::file_info::get_line_offsets(), mxArray_octave_value::get_n(), mxArray_matlab::get_n(), octave::printf_value_cache::get_next_value(), get_object_dims(), get_red_dims(), get_scalar_idx(), get_sort_mode(), octave::sys::file_stat::get_stats(), octave::sys::file_fstat::get_stats(), get_struct_elts(), get_vec_dims(), octave_fields::getfield(), gsvd< T >::ggsvd(), octave::opengl_functions::glDeleteTextures(), octave::opengl_functions::glGenTextures(), octave::sys::glob(), glpk(), octave::call_stack::goto_frame(), octave::tree_evaluator::goto_frame(), octave_value_list::has_magic_colon(), hdf5_types_compatible(), EIG::hermitian_init(), FloatEIG::hermitian_init(), ichol_0(), ichol_t(), identity_matrix(), octave::identity_matrix(), MArray< T >::idx_add(), MArray< T >::idx_add_nd(), MArray< T >::idx_min(), ComplexNDArray::ifourier(), FloatComplexNDArray::ifourier(), FloatNDArray::ifourier(), ilu_0(), ilu_crout(), ilu_tp(), increment_index(), ind2sub(), Range::index(), Array< T >::index(), Sparse< T >::index(), Cell::index(), idx_vector::index(), index_in_bounds(), FloatEIG::init(), hess< T >::init(), EIG::init(), chol< T >::init(), gepbalance< T >::init(), schur< T >::init(), qr< T >::init(), qrp< T >::init(), octave::init_mersenne_twister(), inner_do_add_sm_dm(), Array< T >::insert(), ComplexNDArray::insert(), FloatComplexNDArray::insert(), qr< T >::insert_col(), qr< T >::insert_row(), chol< T >::insert_sym(), Screen::insertChars(), Screen::insertLines(), DASPK::integrate(), DASSL::integrate(), DASRT::integrate(), SparseComplexMatrix::inverse(), SparseMatrix::inverse(), octave::math::sparse_chol< chol_type >::inverse(), idx_vector::inverse_permutation(), idx_vector::idx_range_rep::is_colon_equiv(), idx_vector::idx_scalar_rep::is_colon_equiv(), idx_vector::idx_mask_rep::is_colon_equiv(), idx_vector::is_colon_equiv(), idx_vector::is_cont_range(), idx_vector::is_permutation(), is_scalar(), octave_sort< T >::is_sorted_rows(), Cell::iscellstr(), Array< T >::issorted(), isvector(), jcobi(), idx_vector::idx_colon_rep::length(), idx_vector::length(), lin_interpn(), linspace(), octave::curl_transfer::list(), octave_perm_matrix::load_ascii(), Array< octave_value * >::lookup(), Array< T >::lookup(), lookup(), idx_vector::loop(), octave_int_arith_base< T, false >::lshift(), octave_int_arith_base< T, true >::lshift(), ComplexMatrix::lssolve(), FloatComplexMatrix::lssolve(), FloatMatrix::lssolve(), Matrix::lssolve(), ltsolve(), LuAminusSigmaB(), octave::tree_index_expression::lvalue(), octave_value_list::make_argv(), make_cholb(), dim_vector::make_nd_vector(), make_option_struct(), octave::tree_evaluator::make_value_list(), mex::malloc(), mxArray::malloc(), mex::malloc_unmarked(), mark_upper_triangular(), glob_match::match(), string_vector::max_length(), octave::tree_evaluator::max_recursion_depth(), idx_vector::maybe_reduce(), mdm_div_impl(), octave_sort< T >::merge_collapse(), octave_sort< T >::merge_compute_minrun(), octave_sort< T >::merge_force_collapse(), octave::math::mod(), mx_inline_all_finite(), mx_inline_all_real(), mx_inline_and2(), mx_inline_any_nan(), mx_inline_any_negative(), mx_inline_any_positive(), mx_inline_diff(), mx_inline_equal(), mx_inline_fill(), mx_inline_imag(), mx_inline_iszero(), mx_inline_map(), mx_inline_not(), mx_inline_not2(), mx_inline_notzero(), mx_inline_or2(), mx_inline_pow(), mx_inline_real(), mx_inline_uminus(), mx_inline_uminus2(), mx_inline_xmax(), mx_inline_xmin(), mxCalloc(), mxCreateCellMatrix(), mxCreateDoubleMatrix(), mxCreateLogicalMatrix(), mxCreateNumericMatrix(), mxCreateSparse(), mxCreateSparseLogicalMatrix(), mxCreateStructMatrix(), mxCreateUninitNumericMatrix(), mxMalloc(), mxSetN(), octave::sys::file_ops::native_separator_path(), CollocWt::ncol(), octave::next_power_of_2(), Array< T >::nth_element(), null(), num2hex(), dim_vector::numel(), octave__scan_bytes(), octave_qhull_dims_ok(), octave_qsort(), octave_strncasecmp(), octave_tex__scan_bytes(), octave_u8_check_wrapper(), octave_u8_tolower_wrapper(), octave_u8_toupper_wrapper(), octregexp(), idx_vector::ones_count(), bsxfun_wrapper< R, X, Y, F >::op_mm(), bsxfun_wrapper< R, X, Y, F >::op_ms(), bsxfun_wrapper< R, X, Y, F >::op_sm(), octave::sys::dir_entry::open(), octave_value_list::operator()(), Array< T >::operator()(), Sparse< T >::operator()(), octave_map::operator()(), idx_vector::operator()(), operator*(), CollocWt::operator=(), octave_fields::orderfields(), octave::textscan::parse_options(), octave::sys::env::pathname_backup(), permute_to_correct_order(), octave::math::aepbalance< MT >::permuting_vector(), octave::poisson_cdf_lookup(), octave::poisson_rejection(), PermMatrix::pos_power(), octave::pown(), octave_value_list::prepend(), octave_range::print_name_tag(), octave::tree_print_code::print_parens(), octave::scanf_format_list::printme(), octave::printf_format_list::printme(), octave::textscan_format_list::printme(), octave::textscan_format_list::process_conversion(), octave::printf_format_list::process_conversion(), octave::scanf_format_list::process_conversion(), octave::math::psi(), put_int(), octave::math::sparse_chol< chol_type >::sparse_chol_rep< chol_type >::Q(), qp(), qs_search(), octave::rand_exponential(), octave::rand_gamma(), octave::rand_normal(), octave::rand_poisson(), octave::rand_uniform(), octave::rand_uniform< double >(), Sparse< T >::range_error(), rational_approx(), read_mat5_binary_element(), mex::realloc(), dim_vector::redim(), reinterpret_copy(), reinterpret_int_copy(), octave::math::rem(), octave::command_history::remove(), mxArray_struct::remove_field(), octave::command_editor::reset_current_command_number(), Sparse< T >::resize(), dim_vector::resize(), ComplexColumnVector::resize(), ComplexRowVector::resize(), ColumnVector::resize(), RowVector::resize(), FloatColumnVector::resize(), FloatRowVector::resize(), FloatComplexColumnVector::resize(), FloatComplexRowVector::resize(), octave_value_list::resize(), string_vector::resize(), DiagArray2< T >::resize(), CollocWt::resize(), Sparse< T >::resize1(), Array< T >::resize1(), dim_vector::resizerep(), octave::call_stack::restore_frame(), octave::tree_evaluator::restore_frame(), octave::file_editor::restore_session(), octave::tree_evaluator::returning(), octave_value_list::reverse(), octave_fields::rmfield(), roundupsize(), octave_int_arith_base< T, false >::rshift(), octave_int_arith_base< T, true >::rshift(), dim_vector::safe_numel(), octave_perm_matrix::save_ascii(), save_mat5_binary_element(), octave::math::aepbalance< MT >::scaling_vector(), Screen::scrollDown(), Screen::scrollUp(), octave::opengl_selector::select(), octave::command_history::set_mark(), mxArray_matlab::set_n(), mxArray::set_n(), octave::command_editor::set_name(), octave::opengl_renderer::set_normal(), octave::command_history::set_size(), Vt102Emulation::setAndUseCharset(), gzfilebuf::setbuf(), Vt102Emulation::setCharset(), Emulation::setScreen(), PermMatrix::setup(), qr< T >::shift_cols(), chol< T >::shift_sym(), octave_sort< T >::sort(), sqrtm_utri_inplace(), stack_complex_matrix(), octave::command_history::stifle(), str_data_cmp(), str_data_cmpi(), octave_char_matrix_str::string_vector_value(), Cell::string_vector_value(), strip_spaces(), octave::string::strncmp(), octave::string::strncmpi(), sub2ind(), octave::cdef_object_array::subsasgn(), octave_cell::subsasgn(), octave_struct::subsasgn(), octave_scalar_struct::subsasgn(), octave_class::subsasgn_common(), octave::cdef_object_array::subsref(), swap_bytes(), symetree(), FloatEIG::symmetric_init(), EIG::symmetric_init(), Screen::Tabulate(), octave::sys::file_ops::tilde_expand(), tree_postorder(), octave::command_history::truncate_file(), unstack_complex_matrix(), chol< T >::update(), lu< T >::update(), qr< T >::update(), lu< T >::update_piv(), QtHandles::Table::updateColumnname(), QtHandles::Table::updateRowname(), QtHandles::updateSelection(), Vt102Emulation::useCharset(), utsolve(), octave::rand::vector(), vector_equivalent(), octave::ft_text_renderer::visit(), octave::tree_evaluator::visit_complex_for_command(), octave::tree_print_code::visit_index_expression(), octave::tree_walker::visit_index_expression(), octave::base_lexer::warn_language_extension_operator(), octave::sys::windows_glob(), idx_vector::idx_mask_rep::xelem(), Array< T >::xelem(), Sparse< T >::xelem(), idx_vector::xelem(), octave::math::xpsi(), c_file_ptr_buf::xsgetn(), c_zfile_ptr_buf::xsgetn(), c_file_ptr_buf::xsputn(), and c_zfile_ptr_buf::xsputn().

nact

octave_idx_type nact = m

Definition at line 816 of file mx-inlines.cc.

octave_local_buffer_iact

std::unique_ptr< octave_idx_type []> octave_local_buffer_iact { new octave_idx_type [ m ] }

Definition at line 816 of file mx-inlines.cc.

r

bool * r

Definition at line 773 of file mx-inlines.cc.

Referenced by color_values::color_values(), DiagArray2< T >::DiagArray2(), dim_vector::dim_vector(), idx_vector::idx_range_rep::idx_range_rep(), Sparse< T >::Sparse(), Sparse< T >::SparseRep::SparseRep(), octave::text_element_color::text_element_color(), Sparse< T >::SparseRep::~SparseRep(), octave::documentation::add_action(), octave::dw_main_window::add_action(), octave::file_editor::add_action(), QtHandles::Figure::addCustomToolBar(), QtHandles::GenericEventNotifySender::addReceiver(), octave::jit_range::all_elements_are_ints(), Sparse< bool >::SparseRep::any_element_is_nan(), octave::tm_const::array_concat_internal(), Array< T >::assign(), idx_vector::assign(), octave_sort< T >::binarysort(), idx_vector::bloop(), QtHandles::boundingBoxToRect(), Sparse< T >::SparseRep::change_length(), DiagArray2< T >::check_idx(), check_qr_dims(), DiagArray2< T >::checkelem(), octave::math::chol2inv(), octave::chol2inv_internal(), Array< T >::clear(), dim_vector::clonerep(), cntr(), ComplexDiagMatrix::column(), DiagMatrix::column(), FloatComplexDiagMatrix::column(), FloatDiagMatrix::column(), Array< T >::column(), idx_vector::complement(), intNDArray< octave_uint8 >::compute_index(), idx_vector::copy_data(), cpolar(), Sparse< T >::SparseRep::cridx(), cross(), qr< T >::delete_col(), Sparse< T >::delete_elements(), qr< T >::delete_row(), divide(), dmperm_internal(), dmsolve_extract(), dmsolve_insert(), dmsolve_permute(), octave::math::do_erfcinv(), octave::math::do_erfinv(), do_inplace_bsxfun_op(), do_leftdiv_dm_sm(), do_mm_binary_op(), do_mm_inplace_op(), do_ms_binary_op(), do_ms_inplace_op(), do_mul_dm_sm(), do_mul_sm_dm(), do_mx_inplace_op(), do_mx_unary_op(), do_rand(), do_rightdiv_sm_dm(), do_sm_binary_op(), do_strcmp_fun(), do_tril(), do_triu(), drawcn(), octave_struct::edit_display(), octave_scalar_struct::edit_display(), EigsComplexNonSymmetricMatrixShift(), EigsRealNonSymmetricMatrixShift(), EigsRealSymmetricMatrixShift(), DiagArray2< T >::elem(), elem_xpow(), F__accumarray_sum__(), Faddpath(), octave_base_diag< DMT, MT >::fast_elem_extract(), octave_perm_matrix::fast_elem_extract(), Fchol2inv(), Fcolloc(), Fdlmread(), idx_vector::fill(), octave::fcn_info::fcn_info_rep::find_scoped_function(), Fisargout(), octave::flogfak(), qr< T >::form(), Frandperm(), Frepelems(), octave::math::qr< T >::get_type(), octave::documentation::global_search_finished(), QConsolePrivate::grabConsoleBuffer(), H_heapify_min(), H_remove_min(), octave::octave_dock_widget::handle_settings(), ichol_0(), ilu_0(), Array< T >::index(), idx_vector::index(), Sparse< T >::SparseRep::indices_ok(), inner_do_add_sm_dm(), Array< T >::insert(), boolMatrix::insert(), boolNDArray::insert(), Cell::insert(), charMatrix::insert(), charNDArray::insert(), ComplexColumnVector::insert(), ColumnVector::insert(), FloatComplexColumnVector::insert(), FloatColumnVector::insert(), FloatComplexMatrix::insert(), FloatMatrix::insert(), FloatNDArray::insert(), ComplexMatrix::insert(), Matrix::insert(), ComplexNDArray::insert(), NDArray::insert(), FloatComplexNDArray::insert(), MSparse< T >::insert(), Sparse< T >::insert(), SparseBoolMatrix::insert(), SparseComplexMatrix::insert(), SparseMatrix::insert(), qr< T >::insert_col(), qr< T >::insert_row(), ComplexDiagMatrix::inverse(), DiagMatrix::inverse(), FloatComplexDiagMatrix::inverse(), FloatDiagMatrix::inverse(), idx_vector::inverse_permutation(), idx_vector::is_cont_range(), Array< T >::is_sorted_rows(), octave_range::is_true(), Array< T >::issorted(), octave_base_diag< DMT, MT >::load_ascii(), octave_complex_diag_matrix::load_binary(), octave_float_complex_diag_matrix::load_binary(), octave_float_diag_matrix::load_binary(), octave_diag_matrix::load_binary(), octave::math::log1p(), idx_vector::loop(), LuAminusSigmaB(), octave::cdef_object_base::make_array(), make_format(), octave::opengl_renderer::make_marker_list(), octave_fields::make_unique(), octave_value::make_unique(), Array< T >::make_unique(), Sparse< T >::make_unique(), QtHandles::Utils::makeImageFromCData(), Cell::map(), mark_facets(), mat2cell_mismatch(), max(), idx_vector::maybe_reduce(), octave_sort< T >::merge_compute_minrun(), min(), octave_int_arith_base< T, true >::mod(), mx_inline_and2(), mx_inline_diff(), mx_inline_fill(), mx_inline_imag(), mx_inline_iszero(), mx_inline_map(), mx_inline_not(), mx_inline_not2(), mx_inline_notzero(), mx_inline_or2(), mx_inline_pow(), mx_inline_real(), mx_inline_uminus(), mx_inline_uminus2(), mx_inline_xmax(), mx_inline_xmin(), dim_vector::newrep(), QtHandles::GenericEventNotifySender::notifyReceiversAfter(), QtHandles::GenericEventNotifySender::notifyReceiversBefore(), octave::octave_jit_cast_range_any(), octave_print_internal(), octinternal_do_mul_colpm_sm(), octinternal_do_mul_sm_colpm(), octinternal_do_mul_sm_rowpm(), bsxfun_wrapper< R, X, Y, F >::op_mm(), bsxfun_wrapper< R, X, Y, F >::op_ms(), bsxfun_wrapper< R, X, Y, F >::op_sm(), SparseBoolMatrix::operator!(), SparseComplexMatrix::operator!(), SparseMatrix::operator!(), octave::jit_operation::signature_cmp::operator()(), DiagArray2< T >::operator()(), operator*(), ComplexDiagMatrix::operator+=(), FloatComplexDiagMatrix::operator+=(), CollocWt::operator=(), DASRT_result::operator=(), octave::math::qr< T >::operator=(), Array< T >::page(), TerminalView::paintFilters(), plus_or_minus(), pr_float(), octave::ft_text_renderer::process_character(), product(), ComplexDiagMatrix::pseudo_inverse(), ComplexMatrix::pseudo_inverse(), DiagMatrix::pseudo_inverse(), Matrix::pseudo_inverse(), FloatComplexMatrix::pseudo_inverse(), FloatMatrix::pseudo_inverse(), FloatComplexDiagMatrix::pseudo_inverse(), FloatDiagMatrix::pseudo_inverse(), Q_deq(), quotient(), octave::math::qr< T >::R(), octave::rand_gamma(), octave::rand_normal< double >(), octave::rand_normal< float >(), idx_vector::raw(), read_mat_binary_data(), octave::math::qr< T >::regular(), QtHandles::GenericEventNotifySender::removeReceiver(), dim_vector::resize(), DiagArray2< T >::resize(), Sparse< T >::resize(), Array< T >::resize2(), dim_vector::resizerep(), Sparse< T >::SparseRep::ridx(), CollocWt::roots(), ComplexDiagMatrix::row(), DiagMatrix::row(), FloatComplexDiagMatrix::row(), FloatDiagMatrix::row(), charMatrix::row_as_string(), octave_range::save_ascii(), octave_complex_diag_matrix::save_binary(), octave_float_complex_diag_matrix::save_binary(), octave_float_diag_matrix::save_binary(), octave_range::save_binary(), octave_diag_matrix::save_binary(), octave_range::save_hdf5(), save_mat_binary_data(), QtHandles::Canvas::select_object(), QtHandles::Figure::set_geometry(), QConsolePrivate::setHorizontalScrollValue(), QConsolePrivate::setVerticalScrollValue(), qr< T >::shift_cols(), QtHandles::Figure::showCustomToolBar(), QtHandles::Figure::showFigureStatusBar(), Array< T >::sort_rows_idx(), sparse_indices_ok(), octave::cdef_object_array::subsref(), octave::opengl_texture::texture_rep::tex_coord(), octave::opengl_texture::tex_coord(), times_or_divide(), times_or_divides(), idx_vector::unconvert(), idx_vector::unmask(), lu< T >::update(), qr< T >::update(), lu< T >::update_piv(), QtHandles::Figure::updateBoundingBox(), QtHandles::Figure::updateFigureHeight(), octave::fcn_info::fcn_info_rep::x_builtin_find(), DiagArray2< T >::xelem(), and xpow().