GNU Octave 11.1.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 
Loading...
Searching...
No Matches
Macros
Sparse-op-defs.h File Reference
#include "octave-config.h"
#include "Array-util.h"
#include "lo-array-errwarn.h"
#include "mx-inlines.cc"
#include "oct-locbuf.h"

Go to the source code of this file.

Macros

#define FULL_SPARSE_MUL(RET_TYPE, EL_TYPE)
 
#define FULL_SPARSE_MUL_TRANS(RET_TYPE, EL_TYPE, CONJ_OP)
 
#define SPARSE_ALL_OP(DIM)
 
#define SPARSE_ANY_ALL_HEADER
 
#define SPARSE_ANY_ALL_OP(DIM, INIT_VAL, MT_RESULT, TEST_OP, TEST_TRUE_VAL)
 
#define SPARSE_ANY_ALL_OP_COL_CODE(TEST_OP, TEST_TRUE_VAL)
 
#define SPARSE_ANY_ALL_OP_ROW_CODE(TEST_OP, TEST_TRUE_VAL)
 
#define SPARSE_ANY_OP(DIM)   SPARSE_ANY_ALL_OP (DIM, false, false, !=, true)
 
#define SPARSE_BASE_REDUCTION_OP(RET_TYPE, EL_TYPE, ROW_EXPR, COL_EXPR, INIT_VAL, MT_RESULT)
 
#define SPARSE_CUMPROD(RET_TYPE, ELT_TYPE, FCN)
 
#define SPARSE_CUMSUM(RET_TYPE, ELT_TYPE, FCN, NAN_EXPR, EXPR)
 
#define SPARSE_FULL_MUL(RET_TYPE, EL_TYPE)
 
#define SPARSE_FULL_TRANS_MUL(RET_TYPE, EL_TYPE, CONJ_OP)
 
#define SPARSE_MSM_BIN_OP(R, F, OP, M1, M2)
 
#define SPARSE_MSM_BIN_OPS(R1, R2, M1, M2)
 
#define SPARSE_MSM_BOOL_AND_OP(F, OP, M1, M2)
 
#define SPARSE_MSM_BOOL_OPS(M1, M2)
 
#define SPARSE_MSM_BOOL_OR_OP(F, OP, M1, M2)
 
#define SPARSE_MSM_CMP_OP(F, OP, M1, M2)
 
#define SPARSE_MSM_CMP_OPS(M1, M2)
 
#define SPARSE_MSM_EQNE_OPS(M1, M2)
 
#define SPARSE_SMM_BIN_OP(R, F, OP, M1, M2)
 
#define SPARSE_SMM_BIN_OPS(R1, R2, M1, M2)
 
#define SPARSE_SMM_BOOL_AND_OP(F, OP, M1, M2)
 
#define SPARSE_SMM_BOOL_OPS(M1, M2)
 
#define SPARSE_SMM_BOOL_OR_OP(F, OP, M1, M2)
 
#define SPARSE_SMM_CMP_OP(F, OP, M1, M2)
 
#define SPARSE_SMM_CMP_OPS(M1, M2)
 
#define SPARSE_SMM_EQNE_OPS(M1, M2)
 
#define SPARSE_SMS_BIN_OP_1(R, F, OP, M, S)
 
#define SPARSE_SMS_BIN_OP_2(R, F, OP, M, S)
 
#define SPARSE_SMS_BIN_OPS(R1, R2, M, S)
 
#define SPARSE_SMS_BOOL_AND_OP(M, S)
 
#define SPARSE_SMS_BOOL_OPS(M, S)
 
#define SPARSE_SMS_BOOL_OR_OP(M, S)
 
#define SPARSE_SMS_CMP_OP(F, OP, M, S)
 
#define SPARSE_SMS_CMP_OPS(M, S)
 
#define SPARSE_SMS_EQNE_OPS(M, S)
 
#define SPARSE_SMSM_BIN_OP_1(R, F, OP, M1, M2)
 
#define SPARSE_SMSM_BIN_OP_2(R, F, OP, M1, M2)
 
#define SPARSE_SMSM_BIN_OP_3(R, F, OP, M1, M2)
 
#define SPARSE_SMSM_BIN_OPS(R1, R2, M1, M2)
 
#define SPARSE_SMSM_BOOL_AND_OP(M1, M2)
 
#define SPARSE_SMSM_BOOL_OPS(M1, M2)
 
#define SPARSE_SMSM_BOOL_OR_OP(M1, M2)
 
#define SPARSE_SMSM_CMP_OP(F, OP, M1, M2)
 
#define SPARSE_SMSM_CMP_OPS(M1, M2)
 
#define SPARSE_SMSM_EQNE_OPS(M1, M2)
 
#define SPARSE_SPARSE_MUL(RET_TYPE, RET_EL_TYPE, EL_TYPE)
 
#define SPARSE_SSM_BIN_OP_1(R, F, OP, S, M)
 
#define SPARSE_SSM_BIN_OP_2(R, F, OP, S, M)
 
#define SPARSE_SSM_BIN_OPS(R1, R2, S, M)
 
#define SPARSE_SSM_BOOL_AND_OP(S, M)
 
#define SPARSE_SSM_BOOL_OPS(S, M)
 
#define SPARSE_SSM_BOOL_OR_OP(S, M)
 
#define SPARSE_SSM_CMP_OP(F, OP, S, M)
 
#define SPARSE_SSM_CMP_OPS(S, M)
 
#define SPARSE_SSM_EQNE_OPS(S, M)
 
#define SPARSE_SUMSQ_HEADER(RET_TYPE, EXPR)
 
#define SPARSE_XSUM_REDUCTION_OP(RET_TYPE, EL_TYPE)
 

Macro Definition Documentation

◆ FULL_SPARSE_MUL

#define FULL_SPARSE_MUL (   RET_TYPE,
  EL_TYPE 
)

Definition at line 3822 of file Sparse-op-defs.h.

◆ FULL_SPARSE_MUL_TRANS

#define FULL_SPARSE_MUL_TRANS (   RET_TYPE,
  EL_TYPE,
  CONJ_OP 
)

Definition at line 3857 of file Sparse-op-defs.h.

◆ SPARSE_ALL_OP

#define SPARSE_ALL_OP (   DIM)
Value:
if ((rows () == 1 && dim == -1) || dim == 1) \
return transpose (). all (0). transpose (); \
else \
{ \
SPARSE_ANY_ALL_OP (DIM, (cidx (j+1) - cidx (j) < nr ? false : true), \
true, ==, false); \
}

Definition at line 3530 of file Sparse-op-defs.h.

◆ SPARSE_ANY_ALL_HEADER

#define SPARSE_ANY_ALL_HEADER
Value:
if (rows () > 0 && cols () > 0 && dim > 1) \
{ \
SparseBoolMatrix r = SparseBoolMatrix (rows (), cols (), nnz ()); \
r.cidx (0) = static_cast<octave_idx_type> (0); \
octave_idx_type nel = 0; \
for (octave_idx_type j = 0; j < cols (); j++) \
{ \
for (octave_idx_type i = cidx (j); i < cidx (j+1); i++) \
if (data (i) != 0.0) \
{ \
r.ridx (nel) = ridx (i); \
r.data (nel++) = true; \
} \
r.cidx (j + 1) = nel; \
} \
r.maybe_compress (false); \
return r; \
}
Sparse::cidx
octave_idx_type * cidx()
Definition Sparse.h:595
Sparse::data
T * data()
Definition Sparse.h:573
Sparse::ridx
octave_idx_type * ridx()
Definition Sparse.h:582
Sparse::maybe_compress
Sparse< T, Alloc > maybe_compress(bool remove_zeros=false)
Definition Sparse.h:530
octave_idx_type

Definition at line 3491 of file Sparse-op-defs.h.

◆ SPARSE_ANY_ALL_OP

#define SPARSE_ANY_ALL_OP (   DIM,
  INIT_VAL,
  MT_RESULT,
  TEST_OP,
  TEST_TRUE_VAL 
)
Value:
SPARSE_BASE_REDUCTION_OP (SparseBoolMatrix, char, \
SPARSE_ANY_ALL_OP_ROW_CODE (TEST_OP, TEST_TRUE_VAL), \
SPARSE_ANY_ALL_OP_COL_CODE (TEST_OP, TEST_TRUE_VAL), \
INIT_VAL, MT_RESULT)
SPARSE_BASE_REDUCTION_OP
#define SPARSE_BASE_REDUCTION_OP(RET_TYPE, EL_TYPE, ROW_EXPR, COL_EXPR, INIT_VAL, MT_RESULT)
Definition Sparse-op-defs.h:3222
SPARSE_ANY_ALL_OP_COL_CODE
#define SPARSE_ANY_ALL_OP_COL_CODE(TEST_OP, TEST_TRUE_VAL)
Definition Sparse-op-defs.h:3517
SPARSE_ANY_ALL_OP_ROW_CODE
#define SPARSE_ANY_ALL_OP_ROW_CODE(TEST_OP, TEST_TRUE_VAL)
Definition Sparse-op-defs.h:3513

Definition at line 3524 of file Sparse-op-defs.h.

◆ SPARSE_ANY_ALL_OP_COL_CODE

#define SPARSE_ANY_ALL_OP_COL_CODE (   TEST_OP,
  TEST_TRUE_VAL 
)
Value:
if (data (i) TEST_OP 0.0) \
{ \
tmp[j] = TEST_TRUE_VAL; \
break; \
}

Definition at line 3517 of file Sparse-op-defs.h.

◆ SPARSE_ANY_ALL_OP_ROW_CODE

#define SPARSE_ANY_ALL_OP_ROW_CODE (   TEST_OP,
  TEST_TRUE_VAL 
)
Value:
if (data (i) TEST_OP 0.0) \
tmp[ridx (i)] = TEST_TRUE_VAL;

Definition at line 3513 of file Sparse-op-defs.h.

◆ SPARSE_ANY_OP

#define SPARSE_ANY_OP (   DIM)    SPARSE_ANY_ALL_OP (DIM, false, false, !=, true)

Definition at line 3539 of file Sparse-op-defs.h.

◆ SPARSE_BASE_REDUCTION_OP

#define SPARSE_BASE_REDUCTION_OP (   RET_TYPE,
  EL_TYPE,
  ROW_EXPR,
  COL_EXPR,
  INIT_VAL,
  MT_RESULT 
)

Definition at line 3222 of file Sparse-op-defs.h.

◆ SPARSE_CUMPROD

#define SPARSE_CUMPROD (   RET_TYPE,
  ELT_TYPE,
  FCN 
)

Definition at line 3118 of file Sparse-op-defs.h.

◆ SPARSE_CUMSUM

#define SPARSE_CUMSUM (   RET_TYPE,
  ELT_TYPE,
  FCN,
  NAN_EXPR,
  EXPR 
)

Definition at line 3014 of file Sparse-op-defs.h.

◆ SPARSE_FULL_MUL

#define SPARSE_FULL_MUL (   RET_TYPE,
  EL_TYPE 
)

Definition at line 3755 of file Sparse-op-defs.h.

◆ SPARSE_FULL_TRANS_MUL

#define SPARSE_FULL_TRANS_MUL (   RET_TYPE,
  EL_TYPE,
  CONJ_OP 
)

Definition at line 3789 of file Sparse-op-defs.h.

◆ SPARSE_MSM_BIN_OP

#define SPARSE_MSM_BIN_OP (   R,
  F,
  OP,
  M1,
  M2 
)
Value:
R \
F (const M1& m1, const M2& m2) \
{ \
R r; \
\
octave_idx_type m1_nr = m1.rows (); \
octave_idx_type m1_nc = m1.cols (); \
\
octave_idx_type m2_nr = m2.rows (); \
octave_idx_type m2_nc = m2.cols (); \
\
if (m2_nr == 1 && m2_nc == 1) \
r = R (m1 OP m2.elem (0,0)); \
else if ((m1_nr == m2_nr && m1_nc == m2_nc) || \
(m1_nr == m2_nr && (m1_nc == 1 || m2_nc == 1)) || \
(m1_nc == m2_nc && (m1_nr == 1 || m2_nr == 1)) || \
(m1_nr == 1 && m2_nc == 1) || \
(m1_nc == 1 && m2_nr == 1)) \
r = R (F (m1, m2.matrix_value ())); \
else \
octave::err_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
\
return r; \
}

Definition at line 2002 of file Sparse-op-defs.h.

◆ SPARSE_MSM_BIN_OPS

#define SPARSE_MSM_BIN_OPS (   R1,
  R2,
  M1,
  M2 
)
Value:
SPARSE_MSM_BIN_OP (R1, operator +, +, M1, M2) \
SPARSE_MSM_BIN_OP (R1, operator -, -, M1, M2) \
SPARSE_MSM_BIN_OP (R2, product, *, M1, M2) \
SPARSE_MSM_BIN_OP (R1, quotient, /, M1, M2)
quotient
ComplexColumnVector quotient(const ComplexColumnVector &x, const ComplexColumnVector &y)
Definition CColVector.h:156
product
ComplexColumnVector product(const ComplexColumnVector &x, const ComplexColumnVector &y)
Definition CColVector.h:156
SPARSE_MSM_BIN_OP
#define SPARSE_MSM_BIN_OP(R, F, OP, M1, M2)
Definition Sparse-op-defs.h:2002

Definition at line 2028 of file Sparse-op-defs.h.

◆ SPARSE_MSM_BOOL_AND_OP

#define SPARSE_MSM_BOOL_AND_OP (   F,
  OP,
  M1,
  M2 
)

Definition at line 2211 of file Sparse-op-defs.h.

◆ SPARSE_MSM_BOOL_OPS

#define SPARSE_MSM_BOOL_OPS (   M1,
  M2 
)
Value:
SPARSE_MSM_BOOL_AND_OP (mx_el_and, &&, M1, M2) \
SPARSE_MSM_BOOL_OR_OP (mx_el_or, ||, M1, M2)
SPARSE_MSM_BOOL_AND_OP
#define SPARSE_MSM_BOOL_AND_OP(F, OP, M1, M2)
Definition Sparse-op-defs.h:2211
mx_el_or
boolMatrix mx_el_or(const boolMatrix &m1, const boolMatrix &m2)
Definition boolMatrix.cc:88
mx_el_and
boolMatrix mx_el_and(const boolMatrix &m1, const boolMatrix &m2)
Definition boolMatrix.cc:88

Definition at line 2502 of file Sparse-op-defs.h.

◆ SPARSE_MSM_BOOL_OR_OP

#define SPARSE_MSM_BOOL_OR_OP (   F,
  OP,
  M1,
  M2 
)

Definition at line 2386 of file Sparse-op-defs.h.

◆ SPARSE_MSM_CMP_OP

#define SPARSE_MSM_CMP_OP (   F,
  OP,
  M1,
  M2 
)

Definition at line 2034 of file Sparse-op-defs.h.

◆ SPARSE_MSM_CMP_OPS

#define SPARSE_MSM_CMP_OPS (   M1,
  M2 
)
Value:
SPARSE_MSM_CMP_OP (mx_el_lt, <, M1, M2) \
SPARSE_MSM_CMP_OP (mx_el_le, <=, M1, M2) \
SPARSE_MSM_CMP_OP (mx_el_ge, >=, M1, M2) \
SPARSE_MSM_CMP_OP (mx_el_gt, >, M1, M2) \
SPARSE_MSM_CMP_OP (mx_el_eq, ==, M1, M2) \
SPARSE_MSM_CMP_OP (mx_el_ne, !=, M1, M2)
SPARSE_MSM_CMP_OP
#define SPARSE_MSM_CMP_OP(F, OP, M1, M2)
Definition Sparse-op-defs.h:2034
mx_el_le
boolMatrix mx_el_le(const boolMatrix &m1, const boolMatrix &m2)
Definition boolMatrix.cc:91
mx_el_ne
boolMatrix mx_el_ne(const boolMatrix &m1, const boolMatrix &m2)
Definition boolMatrix.cc:91
mx_el_gt
boolMatrix mx_el_gt(const boolMatrix &m1, const boolMatrix &m2)
Definition boolMatrix.cc:91
mx_el_eq
boolMatrix mx_el_eq(const boolMatrix &m1, const boolMatrix &m2)
Definition boolMatrix.cc:91
mx_el_lt
boolMatrix mx_el_lt(const boolMatrix &m1, const boolMatrix &m2)
Definition boolMatrix.cc:91
mx_el_ge
boolMatrix mx_el_ge(const boolMatrix &m1, const boolMatrix &m2)
Definition boolMatrix.cc:91

Definition at line 2199 of file Sparse-op-defs.h.

◆ SPARSE_MSM_EQNE_OPS

#define SPARSE_MSM_EQNE_OPS (   M1,
  M2 
)
Value:
SPARSE_MSM_CMP_OP (mx_el_eq, ==, M1, M2) \
SPARSE_MSM_CMP_OP (mx_el_ne, !=, M1, M2)

Definition at line 2207 of file Sparse-op-defs.h.

◆ SPARSE_SMM_BIN_OP

#define SPARSE_SMM_BIN_OP (   R,
  F,
  OP,
  M1,
  M2 
)
Value:
R \
F (const M1& m1, const M2& m2) \
{ \
R r; \
\
octave_idx_type m1_nr = m1.rows (); \
octave_idx_type m1_nc = m1.cols (); \
\
octave_idx_type m2_nr = m2.rows (); \
octave_idx_type m2_nc = m2.cols (); \
\
if (m1_nr == 1 && m1_nc == 1) \
r = R (m1.elem (0,0) OP m2); \
else if ((m1_nr == m2_nr && m1_nc == m2_nc) || \
(m1_nr == m2_nr && (m1_nc == 1 || m2_nc == 1)) || \
(m1_nc == m2_nc && (m1_nr == 1 || m2_nr == 1)) || \
(m1_nr == 1 && m2_nc == 1) || \
(m1_nc == 1 && m2_nr == 1)) \
r = R (F (m1.matrix_value (), m2)); \
else \
octave::err_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
\
return r; \
}

Definition at line 2508 of file Sparse-op-defs.h.

◆ SPARSE_SMM_BIN_OPS

#define SPARSE_SMM_BIN_OPS (   R1,
  R2,
  M1,
  M2 
)
Value:
SPARSE_SMM_BIN_OP (R1, operator +, +, M1, M2) \
SPARSE_SMM_BIN_OP (R1, operator -, -, M1, M2) \
SPARSE_SMM_BIN_OP (R2, product, *, M1, M2) \
SPARSE_SMM_BIN_OP (R2, quotient, /, M1, M2)
SPARSE_SMM_BIN_OP
#define SPARSE_SMM_BIN_OP(R, F, OP, M1, M2)
Definition Sparse-op-defs.h:2508

Definition at line 2534 of file Sparse-op-defs.h.

◆ SPARSE_SMM_BOOL_AND_OP

#define SPARSE_SMM_BOOL_AND_OP (   F,
  OP,
  M1,
  M2 
)

Definition at line 2717 of file Sparse-op-defs.h.

◆ SPARSE_SMM_BOOL_OPS

#define SPARSE_SMM_BOOL_OPS (   M1,
  M2 
)
Value:
SPARSE_SMM_BOOL_AND_OP (mx_el_and, &&, M1, M2) \
SPARSE_SMM_BOOL_OR_OP (mx_el_or, ||, M1, M2)
SPARSE_SMM_BOOL_AND_OP
#define SPARSE_SMM_BOOL_AND_OP(F, OP, M1, M2)
Definition Sparse-op-defs.h:2717

Definition at line 3008 of file Sparse-op-defs.h.

◆ SPARSE_SMM_BOOL_OR_OP

#define SPARSE_SMM_BOOL_OR_OP (   F,
  OP,
  M1,
  M2 
)

Definition at line 2892 of file Sparse-op-defs.h.

◆ SPARSE_SMM_CMP_OP

#define SPARSE_SMM_CMP_OP (   F,
  OP,
  M1,
  M2 
)

Definition at line 2540 of file Sparse-op-defs.h.

◆ SPARSE_SMM_CMP_OPS

#define SPARSE_SMM_CMP_OPS (   M1,
  M2 
)
Value:
SPARSE_SMM_CMP_OP (mx_el_lt, <, M1, M2) \
SPARSE_SMM_CMP_OP (mx_el_le, <=, M1, M2) \
SPARSE_SMM_CMP_OP (mx_el_ge, >=, M1, M2) \
SPARSE_SMM_CMP_OP (mx_el_gt, >, M1, M2) \
SPARSE_SMM_CMP_OP (mx_el_eq, ==, M1, M2) \
SPARSE_SMM_CMP_OP (mx_el_ne, !=, M1, M2)
SPARSE_SMM_CMP_OP
#define SPARSE_SMM_CMP_OP(F, OP, M1, M2)
Definition Sparse-op-defs.h:2540

Definition at line 2705 of file Sparse-op-defs.h.

◆ SPARSE_SMM_EQNE_OPS

#define SPARSE_SMM_EQNE_OPS (   M1,
  M2 
)
Value:
SPARSE_SMM_CMP_OP (mx_el_eq, ==, M1, M2) \
SPARSE_SMM_CMP_OP (mx_el_ne, !=, M1, M2)

Definition at line 2713 of file Sparse-op-defs.h.

◆ SPARSE_SMS_BIN_OP_1

#define SPARSE_SMS_BIN_OP_1 (   R,
  F,
  OP,
  M,
  S 
)
Value:
R \
F (const M& m, const S& s) \
{ \
octave_idx_type nr = m.rows (); \
octave_idx_type nc = m.cols (); \
\
R r (nr, nc, (0.0 OP s)); \
\
for (octave_idx_type j = 0; j < nc; j++) \
for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++) \
r.xelem (m.ridx (i), j) = m.data (i) OP s; \
return r; \
}
M
F77_RET_T const F77_INT const F77_INT const F77_INT const F77_DBLE const F77_DBLE F77_INT & M
Definition lapack-proto.h:904

Definition at line 38 of file Sparse-op-defs.h.

◆ SPARSE_SMS_BIN_OP_2

#define SPARSE_SMS_BIN_OP_2 (   R,
  F,
  OP,
  M,
  S 
)
Value:
R \
F (const M& m, const S& s) \
{ \
octave_idx_type nr = m.rows (); \
octave_idx_type nc = m.cols (); \
octave_idx_type nz = m.nnz (); \
\
R r (nr, nc, nz); \
\
for (octave_idx_type i = 0; i < nz; i++) \
{ \
r.xdata (i) = m.data (i) OP s; \
r.xridx (i) = m.ridx (i); \
} \
for (octave_idx_type i = 0; i < nc + 1; i++) \
r.xcidx (i) = m.cidx (i); \
\
r.maybe_compress (true); \
return r; \
}

Definition at line 53 of file Sparse-op-defs.h.

◆ SPARSE_SMS_BIN_OPS

#define SPARSE_SMS_BIN_OPS (   R1,
  R2,
  M,
  S 
)
Value:
SPARSE_SMS_BIN_OP_1 (R1, operator +, +, M, S) \
SPARSE_SMS_BIN_OP_1 (R1, operator -, -, M, S) \
SPARSE_SMS_BIN_OP_2 (R2, operator *, *, M, S) \
SPARSE_SMS_BIN_OP_2 (R2, operator /, /, M, S)
SPARSE_SMS_BIN_OP_1
#define SPARSE_SMS_BIN_OP_1(R, F, OP, M, S)
Definition Sparse-op-defs.h:38

Definition at line 75 of file Sparse-op-defs.h.

◆ SPARSE_SMS_BOOL_AND_OP

#define SPARSE_SMS_BOOL_AND_OP (   M,
  S 
)

Definition at line 132 of file Sparse-op-defs.h.

◆ SPARSE_SMS_BOOL_OPS

#define SPARSE_SMS_BOOL_OPS (   M,
  S 
)
Value:
SPARSE_SMS_BOOL_AND_OP (M, S) \
SPARSE_SMS_BOOL_OR_OP (M, S)
SPARSE_SMS_BOOL_AND_OP
#define SPARSE_SMS_BOOL_AND_OP(M, S)
Definition Sparse-op-defs.h:132

Definition at line 200 of file Sparse-op-defs.h.

◆ SPARSE_SMS_BOOL_OR_OP

#define SPARSE_SMS_BOOL_OR_OP (   M,
  S 
)
Value:
boolMatrix \
mx_el_or (const M& m, const S& s) \
{ \
octave_idx_type nr = m.rows (); \
octave_idx_type nc = m.cols (); \
boolMatrix r; \
\
M::element_type lhs_zero = M::element_type (); \
S rhs_zero = S (); \
\
if (nr > 0 && nc > 0) \
{ \
if (s != rhs_zero) \
r = boolMatrix (nr, nc, true); \
else \
{ \
r = boolMatrix (nr, nc, false); \
\
for (octave_idx_type j = 0; j < nc; j++) \
for (octave_idx_type i = 0; i < nr; i++) \
if (m.elem (i, j) != lhs_zero) \
r.elem (i, j) = true; \
} \
} \
else \
r = boolMatrix (nr, nc, false); \
return r; \
}
Array::elem
T & elem(octave_idx_type n)
Size of the specified dimension.
Definition Array-base.h:585

Definition at line 170 of file Sparse-op-defs.h.

◆ SPARSE_SMS_CMP_OP

#define SPARSE_SMS_CMP_OP (   F,
  OP,
  M,
  S 
)

Definition at line 81 of file Sparse-op-defs.h.

◆ SPARSE_SMS_CMP_OPS

#define SPARSE_SMS_CMP_OPS (   M,
  S 
)
Value:
SPARSE_SMS_CMP_OP (mx_el_lt, <, M, S) \
SPARSE_SMS_CMP_OP (mx_el_le, <=, M, S) \
SPARSE_SMS_CMP_OP (mx_el_ge, >=, M, S) \
SPARSE_SMS_CMP_OP (mx_el_gt, >, M, S) \
SPARSE_SMS_CMP_OP (mx_el_eq, ==, M, S) \
SPARSE_SMS_CMP_OP (mx_el_ne, !=, M, S)
SPARSE_SMS_CMP_OP
#define SPARSE_SMS_CMP_OP(F, OP, M, S)
Definition Sparse-op-defs.h:81

Definition at line 120 of file Sparse-op-defs.h.

◆ SPARSE_SMS_EQNE_OPS

#define SPARSE_SMS_EQNE_OPS (   M,
  S 
)
Value:
SPARSE_SMS_CMP_OP (mx_el_eq, ==, M, S) \
SPARSE_SMS_CMP_OP (mx_el_ne, !=, M, S)

Definition at line 128 of file Sparse-op-defs.h.

◆ SPARSE_SMSM_BIN_OP_1

#define SPARSE_SMSM_BIN_OP_1 (   R,
  F,
  OP,
  M1,
  M2 
)

Definition at line 375 of file Sparse-op-defs.h.

◆ SPARSE_SMSM_BIN_OP_2

#define SPARSE_SMSM_BIN_OP_2 (   R,
  F,
  OP,
  M1,
  M2 
)

Definition at line 615 of file Sparse-op-defs.h.

◆ SPARSE_SMSM_BIN_OP_3

#define SPARSE_SMSM_BIN_OP_3 (   R,
  F,
  OP,
  M1,
  M2 
)

Definition at line 960 of file Sparse-op-defs.h.

◆ SPARSE_SMSM_BIN_OPS

#define SPARSE_SMSM_BIN_OPS (   R1,
  R2,
  M1,
  M2 
)
Value:
SPARSE_SMSM_BIN_OP_1 (R1, operator +, +, M1, M2) \
SPARSE_SMSM_BIN_OP_1 (R1, operator -, -, M1, M2) \
SPARSE_SMSM_BIN_OP_2 (R2, product, *, M1, M2) \
SPARSE_SMSM_BIN_OP_3 (R2, quotient, /, M1, M2)
SPARSE_SMSM_BIN_OP_1
#define SPARSE_SMSM_BIN_OP_1(R, F, OP, M1, M2)
Definition Sparse-op-defs.h:375

Definition at line 1193 of file Sparse-op-defs.h.

◆ SPARSE_SMSM_BOOL_AND_OP

#define SPARSE_SMSM_BOOL_AND_OP (   M1,
  M2 
)

Definition at line 1581 of file Sparse-op-defs.h.

◆ SPARSE_SMSM_BOOL_OPS

#define SPARSE_SMSM_BOOL_OPS (   M1,
  M2 
)
Value:
SPARSE_SMSM_BOOL_AND_OP (M1, M2) \
SPARSE_SMSM_BOOL_OR_OP (M1, M2)
SPARSE_SMSM_BOOL_AND_OP
#define SPARSE_SMSM_BOOL_AND_OP(M1, M2)
Definition Sparse-op-defs.h:1581

Definition at line 1996 of file Sparse-op-defs.h.

◆ SPARSE_SMSM_BOOL_OR_OP

#define SPARSE_SMSM_BOOL_OR_OP (   M1,
  M2 
)

Definition at line 1759 of file Sparse-op-defs.h.

◆ SPARSE_SMSM_CMP_OP

#define SPARSE_SMSM_CMP_OP (   F,
  OP,
  M1,
  M2 
)

Definition at line 1202 of file Sparse-op-defs.h.

◆ SPARSE_SMSM_CMP_OPS

#define SPARSE_SMSM_CMP_OPS (   M1,
  M2 
)
Value:
SPARSE_SMSM_CMP_OP (mx_el_lt, <, M1, M2) \
SPARSE_SMSM_CMP_OP (mx_el_le, <=, M1, M2) \
SPARSE_SMSM_CMP_OP (mx_el_ge, >=, M1, M2) \
SPARSE_SMSM_CMP_OP (mx_el_gt, >, M1, M2) \
SPARSE_SMSM_CMP_OP (mx_el_eq, ==, M1, M2) \
SPARSE_SMSM_CMP_OP (mx_el_ne, !=, M1, M2)
SPARSE_SMSM_CMP_OP
#define SPARSE_SMSM_CMP_OP(F, OP, M1, M2)
Definition Sparse-op-defs.h:1202

Definition at line 1569 of file Sparse-op-defs.h.

◆ SPARSE_SMSM_EQNE_OPS

#define SPARSE_SMSM_EQNE_OPS (   M1,
  M2 
)
Value:
SPARSE_SMSM_CMP_OP (mx_el_eq, ==, M1, M2) \
SPARSE_SMSM_CMP_OP (mx_el_ne, !=, M1, M2)

Definition at line 1577 of file Sparse-op-defs.h.

◆ SPARSE_SPARSE_MUL

#define SPARSE_SPARSE_MUL (   RET_TYPE,
  RET_EL_TYPE,
  EL_TYPE 
)

Definition at line 3541 of file Sparse-op-defs.h.

◆ SPARSE_SSM_BIN_OP_1

#define SPARSE_SSM_BIN_OP_1 (   R,
  F,
  OP,
  S,
  M 
)
Value:
R \
F (const S& s, const M& m) \
{ \
octave_idx_type nr = m.rows (); \
octave_idx_type nc = m.cols (); \
\
R r (nr, nc, (s OP 0.0)); \
\
for (octave_idx_type j = 0; j < nc; j++) \
for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++) \
r.xelem (m.ridx (i), j) = s OP m.data (i); \
\
return r; \
}

Definition at line 206 of file Sparse-op-defs.h.

◆ SPARSE_SSM_BIN_OP_2

#define SPARSE_SSM_BIN_OP_2 (   R,
  F,
  OP,
  S,
  M 
)
Value:
R \
F (const S& s, const M& m) \
{ \
octave_idx_type nr = m.rows (); \
octave_idx_type nc = m.cols (); \
octave_idx_type nz = m.nnz (); \
\
R r (nr, nc, nz); \
\
for (octave_idx_type i = 0; i < nz; i++) \
{ \
r.xdata (i) = s OP m.data (i); \
r.xridx (i) = m.ridx (i); \
} \
for (octave_idx_type i = 0; i < nc + 1; i++) \
r.xcidx (i) = m.cidx (i); \
\
r.maybe_compress(true); \
return r; \
}

Definition at line 222 of file Sparse-op-defs.h.

◆ SPARSE_SSM_BIN_OPS

#define SPARSE_SSM_BIN_OPS (   R1,
  R2,
  S,
  M 
)
Value:
SPARSE_SSM_BIN_OP_1 (R1, operator +, +, S, M) \
SPARSE_SSM_BIN_OP_1 (R1, operator -, -, S, M) \
SPARSE_SSM_BIN_OP_2 (R2, operator *, *, S, M) \
SPARSE_SSM_BIN_OP_1 (R1, operator /, /, S, M)
SPARSE_SSM_BIN_OP_1
#define SPARSE_SSM_BIN_OP_1(R, F, OP, S, M)
Definition Sparse-op-defs.h:206

Definition at line 244 of file Sparse-op-defs.h.

◆ SPARSE_SSM_BOOL_AND_OP

#define SPARSE_SSM_BOOL_AND_OP (   S,
  M 
)

Definition at line 301 of file Sparse-op-defs.h.

◆ SPARSE_SSM_BOOL_OPS

#define SPARSE_SSM_BOOL_OPS (   S,
  M 
)
Value:
SPARSE_SSM_BOOL_AND_OP (S, M) \
SPARSE_SSM_BOOL_OR_OP (S, M)
SPARSE_SSM_BOOL_AND_OP
#define SPARSE_SSM_BOOL_AND_OP(S, M)
Definition Sparse-op-defs.h:301

Definition at line 369 of file Sparse-op-defs.h.

◆ SPARSE_SSM_BOOL_OR_OP

#define SPARSE_SSM_BOOL_OR_OP (   S,
  M 
)
Value:
boolMatrix \
mx_el_or (const S& s, const M& m) \
{ \
octave_idx_type nr = m.rows (); \
octave_idx_type nc = m.cols (); \
boolMatrix r; \
\
S lhs_zero = S (); \
M::element_type rhs_zero = M::element_type (); \
\
if (nr > 0 && nc > 0) \
{ \
if (s != lhs_zero) \
r = boolMatrix (nr, nc, true); \
else \
{ \
r = boolMatrix (nr, nc, false); \
\
for (octave_idx_type j = 0; j < nc; j++) \
for (octave_idx_type i = 0; i < nr; i++) \
if (m.elem (i, j) != rhs_zero) \
r.elem (i, j) = true; \
} \
} \
else \
r = boolMatrix (nr, nc, false); \
return r; \
}

Definition at line 339 of file Sparse-op-defs.h.

◆ SPARSE_SSM_CMP_OP

#define SPARSE_SSM_CMP_OP (   F,
  OP,
  S,
  M 
)

Definition at line 250 of file Sparse-op-defs.h.

◆ SPARSE_SSM_CMP_OPS

#define SPARSE_SSM_CMP_OPS (   S,
  M 
)
Value:
SPARSE_SSM_CMP_OP (mx_el_lt, <, S, M) \
SPARSE_SSM_CMP_OP (mx_el_le, <=, S, M) \
SPARSE_SSM_CMP_OP (mx_el_ge, >=, S, M) \
SPARSE_SSM_CMP_OP (mx_el_gt, >, S, M) \
SPARSE_SSM_CMP_OP (mx_el_eq, ==, S, M) \
SPARSE_SSM_CMP_OP (mx_el_ne, !=, S, M)
SPARSE_SSM_CMP_OP
#define SPARSE_SSM_CMP_OP(F, OP, S, M)
Definition Sparse-op-defs.h:250

Definition at line 289 of file Sparse-op-defs.h.

◆ SPARSE_SSM_EQNE_OPS

#define SPARSE_SSM_EQNE_OPS (   S,
  M 
)
Value:
SPARSE_SSM_CMP_OP (mx_el_eq, ==, S, M) \
SPARSE_SSM_CMP_OP (mx_el_ne, !=, S, M)

Definition at line 297 of file Sparse-op-defs.h.

◆ SPARSE_SUMSQ_HEADER

#define SPARSE_SUMSQ_HEADER (   RET_TYPE,
  EXPR 
)
Value:
if (rows () > 0 && cols () > 0 && dim > 1) \
{ \
RET_TYPE r = RET_TYPE (rows (), cols (), nnz ()); \
r.cidx (0) = static_cast<octave_idx_type> (0); \
octave_idx_type nel = 0; \
for (octave_idx_type j = 0; j < cols (); j++) \
{ \
for (octave_idx_type i = cidx (j); i < cidx (j+1); i++) \
if (data (i) != 0.0) \
{ \
r.ridx (nel) = ridx (i); \
EXPR \
} \
r.cidx (j + 1) = nel; \
} \
r.maybe_compress (false); \
return r; \
} \
if (dim > 1) \
return *this;
EXPR
#define EXPR

Definition at line 3200 of file Sparse-op-defs.h.

◆ SPARSE_XSUM_REDUCTION_OP

#define SPARSE_XSUM_REDUCTION_OP (   RET_TYPE,
  EL_TYPE 
)

Definition at line 3358 of file Sparse-op-defs.h.