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_FCN(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, 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_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_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, int dim, void(*mx_minmax_op)(const R *, R *, octave_idx_type, octave_idx_type, octave_idx_type))
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 , 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 *))
template<typename T >
void	F (const TSRC *v, TRES *r, octave_idx_type m, octave_idx_type n)
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 (T x)
template<typename T >
bool	logical_value (const std::complex< T > &x)
template<typename T >
bool	logical_value (const octave_int< 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, 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 >
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 >
bool	mx_inline_all (const T *v, octave_idx_type n)
template<typename T >
void	mx_inline_all (const T *v, bool *r, octave_idx_type m, octave_idx_type n)
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 >
bool	mx_inline_all_finite (size_t n, const T *x)
template<typename T >
void	mx_inline_all_r (const T *v, bool *r, octave_idx_type m, octave_idx_type n)
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, Y y)
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, 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 >
bool	mx_inline_any (const T *v, octave_idx_type n)
template<typename T >
void	mx_inline_any (const T *v, bool *r, octave_idx_type m, octave_idx_type n)
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_any_r (const T *v, bool *r, octave_idx_type m, octave_idx_type n)
template<typename T >
T	mx_inline_count (const bool *v, octave_idx_type n)
template<typename T >
void	mx_inline_count (const bool *v, T *r, octave_idx_type m, octave_idx_type n)
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 n)
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 l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_cummax (const T *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 n)
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 *ri, octave_idx_type m, 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 *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 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 *ri, octave_idx_type m, octave_idx_type n)
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 *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 l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_cumprod (const T *v, T *r, octave_idx_type n)
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 l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_cumsum (const T *v, T *r, octave_idx_type n)
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 l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_diff (const T *v, T *r, octave_idx_type n, 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 l, octave_idx_type n, octave_idx_type u, octave_idx_type order)
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 , 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, const X *x, const Y *y)
template<typename R , typename X >
void	mx_inline_div2 (size_t n, R *r, X x)
template<typename R , typename X >
void	mx_inline_div2 (size_t n, R *r, const X *x)
template<typename T >
subst_template_param< std::complex, T, double >::type	mx_inline_dprod (const T *v, octave_idx_type n)
template<typename T >
void	mx_inline_dprod (const T *v, typename subst_template_param< std::complex, T, double >::type *r, octave_idx_type m, octave_idx_type n)
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 >
subst_template_param< std::complex, T, double >::type	mx_inline_dsum (const T *v, octave_idx_type n)
template<typename T >
void	mx_inline_dsum (const T *v, typename subst_template_param< std::complex, T, double >::type *r, octave_idx_type m, octave_idx_type n)
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 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 m, octave_idx_type n)
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 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 l, octave_idx_type n, octave_idx_type u)
template<typename T >
void	mx_inline_min (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 n)
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 m, 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 *ri, octave_idx_type l, octave_idx_type n, octave_idx_type u)
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, X x)
template<typename R , typename X >
void	mx_inline_mul2 (size_t n, R *r, const 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 >
T	mx_inline_prod (const T *v, octave_idx_type n)
template<typename T >
void	mx_inline_prod (const T *v, T *r, octave_idx_type m, octave_idx_type n)
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, 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 >
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 m, 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 >
T	mx_inline_sumsq (const T *v, octave_idx_type n)
template<typename T >
T	mx_inline_sumsq (const std::complex< T > *v, octave_idx_type n)
template<typename T >
void	mx_inline_sumsq (const T *v, T *r, octave_idx_type m, octave_idx_type n)
template<typename T >
void	mx_inline_sumsq (const std::complex< T > *v, T *r, octave_idx_type m, 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 std::complex< T > *v, T *r, octave_idx_type l, octave_idx_type n, octave_idx_type u)
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, double x, const double *y)
template<>
void	mx_inline_xmax< double > (size_t n, double *r, const double *x, 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, float x, const float *y)
template<>
void	mx_inline_xmin< float > (size_t n, float *r, const float *x, 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 m, 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)
void	op_dble_prod (double &ac, float el)
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_sum (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)
template<typename T >
void	twosum_accum (T &s, T &e, const T &x)
template<typename T >
bool	xis_false (T x)
template<typename T >
bool	xis_false (const octave_int< T > &x)
bool	xis_false (double x)
bool	xis_false (float x)
bool	xis_false (const Complex &x)
bool	xis_false (const FloatComplex &x)
template<typename T >
bool	xis_true (T x)
template<typename T >
bool	xis_true (const octave_int< T > &x)
bool	xis_true (double x)
bool	xis_true (float x)
bool	xis_true (const Complex &x)
bool	xis_true (const FloatComplex &x)

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 382 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 86 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 111 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 192 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 130 of file mx-inlines.cc.

octave_mx_inlines_h

#define octave_mx_inlines_h   1

Definition at line 26 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 844 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 861 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 885 of file mx-inlines.cc.

OP_CUMMINMAX_FCN

#define OP_CUMMINMAX_FCN	(		F,
			OP
	)

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

OP_CUMMINMAX_FCN2

#define OP_CUMMINMAX_FCN2	(		F,
			OP
	)

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

OP_CUMMINMAX_FCNN

#define OP_CUMMINMAX_FCNN

(

F

)

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

OP_MINMAX_FCN

#define OP_MINMAX_FCN	(		F,
			OP
	)

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

OP_MINMAX_FCN2

#define OP_MINMAX_FCN2	(		F,
			OP
	)

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

OP_MINMAX_FCNN

#define OP_MINMAX_FCNN

(

F

)

Definition at line 1057 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 728 of file mx-inlines.cc.

OP_RED_ALLR

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

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

OP_RED_ANYC

#define OP_RED_ANYC	(		ac,
			el
	)

Value:

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

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

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 737 of file mx-inlines.cc.

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 809 of file mx-inlines.cc.

OP_RED_PROD

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

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

OP_RED_SUM

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

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

OP_RED_SUMSQ

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

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

OP_RED_SUMSQC

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

Definition at line 676 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;       \
  }

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

PROMOTE_DOUBLE

#define PROMOTE_DOUBLE

(

T

)

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

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

Function Documentation

cabsq()

template<typename T >

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

inline

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

References c.

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 497 of file mx-inlines.cc.

References do_bsxfun_op(), octave::err_nonconformant(), Array< T >::fortran_vec(), is_valid_bsxfun(), Array< T >::numel(), x, and y.

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 541 of file mx-inlines.cc.

References Array< T >::dims(), do_inplace_bsxfun_op(), octave::err_nonconformant(), Array< T >::fortran_vec(), is_valid_inplace_bsxfun(), Array< T >::numel(), 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 521 of file mx-inlines.cc.

References Array< T >::fortran_vec(), Array< T >::numel(), x, and y.

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 560 of file mx-inlines.cc.

References Array< T >::fortran_vec(), Array< T >::numel(), 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 579 of file mx-inlines.cc.

References a.

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 1544 of file mx-inlines.cc.

do_mx_cumminmax_op() [1/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 1604 of file mx-inlines.cc.

do_mx_cumminmax_op() [2/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 1620 of file mx-inlines.cc.

References Array< T >::data(), dims, Array< T >::dims(), Array< T >::fortran_vec(), get_extent_triplet(), and u.

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 1639 of file mx-inlines.cc.

References Array< T >::data(), dims, Array< T >::dims(), Array< T >::fortran_vec(), get_extent_triplet(), and u.

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 488 of file mx-inlines.cc.

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

do_mx_minmax_op() [1/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 1561 of file mx-inlines.cc.

References Array< T >::data(), dims, Array< T >::dims(), Array< T >::fortran_vec(), get_extent_triplet(), and u.

do_mx_minmax_op() [2/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 1581 of file mx-inlines.cc.

References Array< T >::data(), dims, Array< T >::dims(), Array< T >::fortran_vec(), get_extent_triplet(), and u.

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 1520 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 474 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 462 of file mx-inlines.cc.

References 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 531 of file mx-inlines.cc.

References Array< T >::fortran_vec(), Array< T >::numel(), x, and y.

Referenced by max(), and min().

F()

template<typename T >

void F ( const TSRC *  v, TRES *  r, octave_idx_type  m, octave_idx_type  n  )

inline

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

Referenced by G__voronoi__(), Gsymbfact(), and axes::properties::update_camera().

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 1489 of file mx-inlines.cc.

Referenced by do_mx_cumminmax_op(), do_mx_diff_op(), do_mx_minmax_op(), and MArray< Complex >::idx_add_nd().

logical_value() [1/3]

template<typename T >

bool logical_value ( T  x )

inline

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

References x.

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

logical_value() [2/3]

template<typename T >

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

inline

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

References x.

logical_value() [3/3]

template<typename T >

bool logical_value ( const octave_int< T > &  x )

inline

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

References x.

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 106 of file mx-inlines.cc.

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

mx_inline_add() [2/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 106 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, const X *  x, Y  y  )

inline

Definition at line 106 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 125 of file mx-inlines.cc.

Referenced by Sparse< bool >::assign(), MArray< Complex >::idx_add_nd(), operator+=(), ComplexRowVector::operator+=(), ComplexColumnVector::operator+=(), FloatComplexRowVector::operator+=(), FloatComplexColumnVector::operator+=(), ComplexDiagMatrix::operator+=(), FloatComplexDiagMatrix::operator+=(), ComplexMatrix::operator+=(), and FloatComplexMatrix::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 125 of file mx-inlines.cc.

mx_inline_all() [1/3]

template<typename T >

bool mx_inline_all ( const T *  v, octave_idx_type  n  )

inline

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

Referenced by boolNDArray::all(), charNDArray::all(), ComplexNDArray::all(), FloatComplexNDArray::all(), intNDArray< OCTAVE_INT_T >::all(), FloatNDArray::all(), and NDArray::all().

mx_inline_all() [2/3]

template<typename T >

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

inline

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

mx_inline_all() [3/3]

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 842 of file mx-inlines.cc.

mx_inline_all_finite()

template<typename T >

bool mx_inline_all_finite ( size_t  n, const T *  x  )

inline

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

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

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

mx_inline_all_r()

template<typename T >

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

inline

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

mx_inline_all_real()

template<typename T >

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

inline

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

References i, imag(), and x.

Referenced by ComplexNDArray::all_elements_are_real(), FloatComplexNDArray::all_elements_are_real(), ComplexDiagMatrix::all_elements_are_real(), FloatComplexDiagMatrix::all_elements_are_real(), and SparseComplexMatrix::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, Y  y  )

inline

Definition at line 215 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, const Y *  y  )

inline

Definition at line 215 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 215 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 224 of file mx-inlines.cc.

References i, logical_value(), 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 232 of file mx-inlines.cc.

References i, 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 219 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 219 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 219 of file mx-inlines.cc.

mx_inline_any() [1/3]

template<typename T >

bool mx_inline_any ( const T *  v, octave_idx_type  n  )

inline

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

Referenced by boolNDArray::any(), charNDArray::any(), ComplexNDArray::any(), FloatComplexNDArray::any(), intNDArray< OCTAVE_INT_T >::any(), FloatNDArray::any(), and NDArray::any().

mx_inline_any() [2/3]

template<typename T >

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

inline

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

mx_inline_any() [3/3]

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 841 of file mx-inlines.cc.

mx_inline_any_nan()

template<typename T >

bool mx_inline_any_nan ( size_t  n, const T *  x  )

inline

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

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

Referenced by ComplexNDArray::any_element_is_nan(), FloatComplexNDArray::any_element_is_nan(), FloatNDArray::any_element_is_nan(), and NDArray::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 282 of file mx-inlines.cc.

References i, and x.

Referenced by FloatNDArray::any_element_is_negative(), and NDArray::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 295 of file mx-inlines.cc.

References i, and x.

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

mx_inline_any_r()

template<typename T >

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

inline

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

mx_inline_count() [1/3]

template<typename T >

T mx_inline_count ( const bool *  v, octave_idx_type  n  )

inline

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

Referenced by boolNDArray::sum().

mx_inline_count() [2/3]

template<typename T >

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

inline

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

mx_inline_count() [3/3]

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 836 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  n  )

inline

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

Referenced by boolNDArray::cumsum().

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 883 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  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 913 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	n
	)

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

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

mx_inline_cummax() [2/6]

template<typename T >

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

Definition at line 1184 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  m, octave_idx_type  n  )

inline

Definition at line 1318 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 *  ri, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 1318 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  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1377 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 *  ri, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

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

mx_inline_cummin() [1/6]

template<typename T >

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

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

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

mx_inline_cummin() [2/6]

template<typename T >

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

Definition at line 1183 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  m, octave_idx_type  n  )

inline

Definition at line 1317 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  m, octave_idx_type  n  )

inline

Definition at line 1317 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 *  ri, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1376 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  l, octave_idx_type  n, octave_idx_type  u  )

inline

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

mx_inline_cumprod() [1/3]

template<typename T >

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

inline

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

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

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 882 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  l, octave_idx_type  n, octave_idx_type  u  )

inline

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

mx_inline_cumsum() [1/3]

template<typename T >

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

inline

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

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

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 881 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  l, octave_idx_type  n, octave_idx_type  u  )

inline

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

mx_inline_diff() [1/3]

template<typename T >

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

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

References dif(), i, and OCTAVE_LOCAL_BUFFER.

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

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 1421 of file mx-inlines.cc.

References i.

mx_inline_diff() [3/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 1462 of file mx-inlines.cc.

References i.

mx_inline_div() [1/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 109 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 109 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, const X *  x, const Y *  y  )

inline

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

mx_inline_div2() [1/2]

template<typename R , typename X >

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

inline

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

mx_inline_div2() [2/2]

template<typename R , typename X >

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

inline

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

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

mx_inline_dprod() [1/3]

template<typename T >

subst_template_param<std::complex, T , double>::type mx_inline_dprod ( const T *  v, octave_idx_type  n  )

inline

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

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

mx_inline_dprod() [2/3]

template<typename T >

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

inline

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

mx_inline_dprod() [3/3]

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 838 of file mx-inlines.cc.

mx_inline_dsum() [1/3]

template<typename T >

subst_template_param<std::complex, T , double>::type mx_inline_dsum ( const T *  v, octave_idx_type  n  )

inline

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

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

mx_inline_dsum() [2/3]

template<typename T >

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

inline

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

mx_inline_dsum() [3/3]

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 835 of file mx-inlines.cc.

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 154 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 154 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 154 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 569 of file mx-inlines.cc.

References i, x, and y.

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

mx_inline_fill()

template<typename R , typename S >

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

inline

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

References i, and s.

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 153 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 153 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 153 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 152 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 152 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 152 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 327 of file mx-inlines.cc.

References i, imag(), and x.

Referenced by imag().

mx_inline_iszero()

template<typename X >

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

inline

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

References i, x, and zero().

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 151 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 151 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 151 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 150 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 150 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 150 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 444 of file mx-inlines.cc.

References i, and x.

mx_inline_max() [1/6]

template<typename T >

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

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

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

mx_inline_max() [2/6]

template<typename T >

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

Definition at line 962 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  m, octave_idx_type  n  )

inline

Definition at line 1055 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 *  ri, octave_idx_type  m, octave_idx_type  n  )

inline

Definition at line 1055 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  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1113 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 *  ri, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

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

mx_inline_min() [1/6]

template<typename T >

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

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

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

mx_inline_min() [2/6]

template<typename T >

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

Definition at line 961 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  m, octave_idx_type  n  )

inline

Definition at line 1054 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  m, octave_idx_type  n  )

inline

Definition at line 1054 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  l, octave_idx_type  n, octave_idx_type  u  )

inline

Definition at line 1112 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 *  ri, octave_idx_type  l, octave_idx_type  n, octave_idx_type  u  )

inline

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

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 108 of file mx-inlines.cc.

Referenced by kron(), and operator*().

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 108 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 108 of file mx-inlines.cc.

mx_inline_mul2() [1/2]

template<typename R , typename X >

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

inline

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

mx_inline_mul2() [2/2]

template<typename R , typename X >

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

inline

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

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

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 155 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 155 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 155 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 180 of file mx-inlines.cc.

References i, logical_value(), and x.

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

mx_inline_not2()

void mx_inline_not2 ( size_t  n, bool *  r  )

inline

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

References i.

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 217 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 217 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 217 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 218 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 218 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 218 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 79 of file mx-inlines.cc.

References i, x, and zero().

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 216 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 216 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 216 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 240 of file mx-inlines.cc.

References i, logical_value(), 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 248 of file mx-inlines.cc.

References i, 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 220 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 220 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 220 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 413 of file mx-inlines.cc.

References i, pow(), x, and y.

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 423 of file mx-inlines.cc.

References i, pow(), x, and y.

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 433 of file mx-inlines.cc.

References i, pow(), x, and y.

mx_inline_prod() [1/3]

template<typename T >

T mx_inline_prod ( const T *  v, octave_idx_type  n  )

inline

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

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

mx_inline_prod() [2/3]

template<typename T >

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

inline

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

mx_inline_prod() [3/3]

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 837 of file mx-inlines.cc.

mx_inline_real()

template<typename T >

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

inline

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

References i, real(), and x.

Referenced by real().

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 107 of file mx-inlines.cc.

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

mx_inline_sub() [2/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 107 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, const X *  x, Y  y  )

inline

Definition at line 107 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 126 of file mx-inlines.cc.

Referenced by operator-=(), ComplexRowVector::operator-=(), ComplexColumnVector::operator-=(), FloatComplexRowVector::operator-=(), FloatComplexColumnVector::operator-=(), ComplexMatrix::operator-=(), and FloatComplexMatrix::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 126 of file mx-inlines.cc.

mx_inline_sum() [1/3]

template<typename T >

T mx_inline_sum ( const T *  v, octave_idx_type  n  )

inline

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

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

mx_inline_sum() [2/3]

template<typename T >

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

inline

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

mx_inline_sum() [3/3]

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 834 of file mx-inlines.cc.

mx_inline_sumsq() [1/6]

template<typename T >

T mx_inline_sumsq ( const T *  v, octave_idx_type  n  )

inline

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

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

mx_inline_sumsq() [2/6]

template<typename T >

T mx_inline_sumsq ( const std::complex< T > *  v, octave_idx_type  n  )

inline

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

mx_inline_sumsq() [3/6]

template<typename T >

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

inline

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

mx_inline_sumsq() [4/6]

template<typename T >

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

inline

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

mx_inline_sumsq() [5/6]

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 839 of file mx-inlines.cc.

mx_inline_sumsq() [6/6]

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 840 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 54 of file mx-inlines.cc.

References i, and x.

Referenced by operator-().

mx_inline_uminus2()

template<typename R >

void mx_inline_uminus2 ( size_t  n, R *  r  )

inline

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

References i.

Referenced by MArray< Complex >::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 359 of file mx-inlines.cc.

References i, octave::math::max(), x, and y.

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 367 of file mx-inlines.cc.

References i, octave::math::max(), x, and y.

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 375 of file mx-inlines.cc.

References i, octave::math::max(), x, and y.

mx_inline_xmax< double >() [1/2]

template<>

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

inline

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

mx_inline_xmax< double >() [2/2]

template<>

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

inline

Definition at line 403 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 405 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 405 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 335 of file mx-inlines.cc.

References i, octave::math::min(), x, and y.

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 343 of file mx-inlines.cc.

References i, octave::math::min(), x, and y.

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 351 of file mx-inlines.cc.

References i, octave::math::min(), x, and y.

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 402 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 402 of file mx-inlines.cc.

mx_inline_xmin< float >() [1/2]

template<>

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

inline

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

mx_inline_xmin< float >() [2/2]

template<>

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

inline

Definition at line 404 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 1688 of file mx-inlines.cc.

References s, t, and x.

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  m, octave_idx_type  n  )

inline

Definition at line 1700 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  l, octave_idx_type  n, octave_idx_type  u  )

inline

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

References e, i, OCTAVE_LOCAL_BUFFER, and twosum_accum().

op_dble_prod() [1/3]

void op_dble_prod ( double &  ac, float  el  )

inline

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

op_dble_prod() [2/3]

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

inline

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

op_dble_prod() [3/3]

template<typename T >

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

inline

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

References octave_int< T >::double_value().

op_dble_sum() [1/3]

void op_dble_sum ( double &  ac, float  el  )

inline

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

op_dble_sum() [2/3]

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

inline

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

op_dble_sum() [3/3]

template<typename T >

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

inline

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

References octave_int< T >::double_value().

twosum_accum()

template<typename T >

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

inline

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

References dims.

Referenced by mx_inline_xsum().

xis_false() [1/6]

template<typename T >

bool xis_false ( T  x )

inline

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

References x.

xis_false() [2/6]

template<typename T >

bool xis_false ( const octave_int< T > &  x )

inline

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

References x.

xis_false() [3/6]

bool xis_false ( double  x )

inline

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

References x.

xis_false() [4/6]

bool xis_false ( float  x )

inline

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

References x.

xis_false() [5/6]

bool xis_false ( const Complex &  x )

inline

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

References x.

xis_false() [6/6]

bool xis_false ( const FloatComplex &  x )

inline

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

References x.

xis_true() [1/6]

template<typename T >

bool xis_true ( T  x )

inline

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

References x.

xis_true() [2/6]

template<typename T >

bool xis_true ( const octave_int< T > &  x )

inline

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

References x.

xis_true() [3/6]

bool xis_true ( double  x )

inline

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

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

xis_true() [4/6]

bool xis_true ( float  x )

inline

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

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

xis_true() [5/6]

bool xis_true ( const Complex &  x )

inline

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

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

xis_true() [6/6]

bool xis_true ( const FloatComplex &  x )

inline

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

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