Sparse-op-defs.h File Reference

#include "octave-config.h"
#include "Array-util.h"
#include "oct-locbuf.h"
#include "mx-inlines.cc"

Include dependency graph for Sparse-op-defs.h:

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

Go to the source code of this file.

Macros
#define	FULL_SPARSE_MUL(RET_TYPE, EL_TYPE, ZERO)
#define	FULL_SPARSE_MUL_TRANS(RET_TYPE, EL_TYPE, ZERO, CONJ_OP)
#define	SPARSE_ALL_OP(DIM)
#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)
#define	SPARSE_FULL_MUL(RET_TYPE, EL_TYPE, ZERO)
#define	SPARSE_FULL_TRANS_MUL(RET_TYPE, EL_TYPE, ZERO, CONJ_OP)
#define	SPARSE_MSM_BIN_OP_1(R, F, OP, M1, M2)
#define	SPARSE_MSM_BIN_OP_2(R, F, OP, M1, M2)
#define	SPARSE_MSM_BIN_OPS(R1, R2, M1, M2)
#define	SPARSE_MSM_BOOL_OP(F, OP, M1, M2, LHS_ZERO, RHS_ZERO)
#define	SPARSE_MSM_BOOL_OPS(M1, M2, ZERO)   SPARSE_MSM_BOOL_OPS2(M1, M2, ZERO, ZERO)
#define	SPARSE_MSM_BOOL_OPS2(M1, M2, LHS_ZERO, RHS_ZERO)
#define	SPARSE_MSM_CMP_OP(F, OP, M1, C1, M2, C2)
#define	SPARSE_MSM_CMP_OPS(M1, Z1, C1, M2, Z2, C2)
#define	SPARSE_MSM_EQNE_OPS(M1, Z1, C1, M2, Z2, C2)
#define	SPARSE_REDUCTION_OP(RET_TYPE, EL_TYPE, OP, INIT_VAL, MT_RESULT)
#define	SPARSE_REDUCTION_OP_COL_EXPR(OP)   tmp[j] OP data (i)
#define	SPARSE_REDUCTION_OP_ROW_EXPR(OP)   tmp[ridx (i)] OP data (i)
#define	SPARSE_SMM_BIN_OP_1(R, F, OP, M1, M2)
#define	SPARSE_SMM_BIN_OP_2(R, F, OP, M1, M2)
#define	SPARSE_SMM_BIN_OP_2_CHECK_product(ET)   do_mx_check (m2, mx_inline_all_finite<ET>)
#define	SPARSE_SMM_BIN_OP_2_CHECK_quotient(ET)   ! do_mx_check (m2, mx_inline_any_nan<ET>) && m2.nnz () == m2.numel ()
#define	SPARSE_SMM_BIN_OPS(R1, R2, M1, M2)
#define	SPARSE_SMM_BOOL_OP(F, OP, M1, M2, LHS_ZERO, RHS_ZERO)
#define	SPARSE_SMM_BOOL_OPS(M1, M2, ZERO)   SPARSE_SMM_BOOL_OPS2(M1, M2, ZERO, ZERO)
#define	SPARSE_SMM_BOOL_OPS2(M1, M2, LHS_ZERO, RHS_ZERO)
#define	SPARSE_SMM_CMP_OP(F, OP, M1, C1, M2, C2)
#define	SPARSE_SMM_CMP_OPS(M1, Z1, C1, M2, Z2, C2)
#define	SPARSE_SMM_EQNE_OPS(M1, Z1, C1, M2, Z2, C2)
#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_OP(F, OP, M, S, LHS_ZERO, RHS_ZERO)
#define	SPARSE_SMS_BOOL_OPS(M, S, ZERO)   SPARSE_SMS_BOOL_OPS2(M, S, ZERO, ZERO)
#define	SPARSE_SMS_BOOL_OPS2(M, S, LHS_ZERO, RHS_ZERO)
#define	SPARSE_SMS_CMP_OP(F, OP, M, MZ, MC, S, SZ, SC)
#define	SPARSE_SMS_CMP_OPS(M, MZ, CM, S, SZ, CS)
#define	SPARSE_SMS_EQNE_OPS(M, MZ, CM, S, SZ, CS)
#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_OP(F, OP, M1, M2, LHS_ZERO, RHS_ZERO)
#define	SPARSE_SMSM_BOOL_OPS(M1, M2, ZERO)   SPARSE_SMSM_BOOL_OPS2(M1, M2, ZERO, ZERO)
#define	SPARSE_SMSM_BOOL_OPS2(M1, M2, LHS_ZERO, RHS_ZERO)
#define	SPARSE_SMSM_CMP_OP(F, OP, M1, Z1, C1, M2, Z2, C2)
#define	SPARSE_SMSM_CMP_OPS(M1, Z1, C1, M2, Z2, C2)
#define	SPARSE_SMSM_EQNE_OPS(M1, Z1, C1, M2, Z2, C2)
#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_OP(F, OP, S, M, LHS_ZERO, RHS_ZERO)
#define	SPARSE_SSM_BOOL_OPS(S, M, ZERO)   SPARSE_SSM_BOOL_OPS2(S, M, ZERO, ZERO)
#define	SPARSE_SSM_BOOL_OPS2(S, M, LHS_ZERO, RHS_ZERO)
#define	SPARSE_SSM_CMP_OP(F, OP, S, SZ, SC, M, MZ, MC)
#define	SPARSE_SSM_CMP_OPS(S, SZ, SC, M, MZ, MC)
#define	SPARSE_SSM_EQNE_OPS(S, SZ, SC, M, MZ, MC)

Macro Definition Documentation

#define FULL_SPARSE_MUL	(		RET_TYPE,
			EL_TYPE,
			ZERO
	)

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

Referenced by operator*().

#define FULL_SPARSE_MUL_TRANS	(		RET_TYPE,
			EL_TYPE,
			ZERO,
			CONJ_OP
	)

Value:

octave_idx_type nr = m.rows ();                                       \
  octave_idx_type nc = m.cols ();                                       \
                                                                        \
  octave_idx_type a_nr = a.rows ();                                     \
  octave_idx_type a_nc = a.cols ();                                     \
                                                                        \
  if (a_nr == 1 && a_nc == 1)                                           \
    {                                                                   \
      RET_TYPE retval = m * CONJ_OP (a.elem (0,0));                     \
      return retval;                                                    \
    }                                                                   \
  else if (nc != a_nc)                                                  \
    octave::err_nonconformant ("operator *", nr, nc, a_nc, a_nr);               \
  else                                                                  \
    {                                                                   \
      RET_TYPE retval (nr, a_nr, ZERO);                                 \
                                                                        \
      for (octave_idx_type i = 0; i < a_nc ; i++)                       \
        {                                                               \
          octave_quit ();                                               \
          for (octave_idx_type j = a.cidx (i); j < a.cidx (i+1); j++)   \
            {                                                           \
              octave_idx_type col = a.ridx (j);                         \
              EL_TYPE tmpval = CONJ_OP (a.data (j));                    \
              for (octave_idx_type k = 0 ; k < nr; k++)                 \
                retval.xelem (k,col) += tmpval * m.elem (k,i);          \
            }                                                           \
        }                                                               \
      return retval;                                                    \
    }

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

Referenced by mul_herm(), and mul_trans().

#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 1683 of file Sparse-op-defs.h.

Referenced by SparseBoolMatrix::all(), SparseMatrix::all(), and SparseComplexMatrix::all().

#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)

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

#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 1670 of file Sparse-op-defs.h.

#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 1666 of file Sparse-op-defs.h.

#define SPARSE_ANY_OP

(

DIM

)

SPARSE_ANY_ALL_OP (DIM, false, false, !=, true)

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

Referenced by SparseMatrix::any(), and SparseComplexMatrix::any().

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

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

Referenced by SparseMatrix::sumsq(), and SparseComplexMatrix::sumsq().

#define SPARSE_CUMPROD	(		RET_TYPE,
			ELT_TYPE,
			FCN
	)

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

Referenced by SparseMatrix::cumprod(), and SparseComplexMatrix::cumprod().

#define SPARSE_CUMSUM	(		RET_TYPE,
			ELT_TYPE,
			FCN
	)

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

Referenced by SparseMatrix::cumsum(), and SparseComplexMatrix::cumsum().

#define SPARSE_FULL_MUL	(		RET_TYPE,
			EL_TYPE,
			ZERO
	)

Value:

octave_idx_type nr = m.rows ();                                       \
  octave_idx_type nc = m.cols ();                                       \
                                                                        \
  octave_idx_type a_nr = a.rows ();                                     \
  octave_idx_type a_nc = a.cols ();                                     \
                                                                        \
  if (nr == 1 && nc == 1)                                               \
    {                                                                   \
      RET_TYPE retval = m.elem (0,0) * a;                               \
      return retval;                                                    \
    }                                                                   \
  else if (nc != a_nr)                                                  \
    octave::err_nonconformant ("operator *", nr, nc, a_nr, a_nc);               \
  else                                                                  \
    {                                                                   \
      RET_TYPE retval (nr, a_nc, ZERO);                                 \
                                                                        \
      for (octave_idx_type i = 0; i < a_nc ; i++)                       \
        {                                                               \
          for (octave_idx_type j = 0; j < a_nr; j++)                    \
            {                                                           \
              octave_quit ();                                           \
                                                                        \
              EL_TYPE tmpval = a.elem (j,i);                            \
              for (octave_idx_type k = m.cidx (j) ; k < m.cidx (j+1); k++) \
                retval.elem (m.ridx (k),i) += tmpval * m.data (k);      \
            }                                                           \
        }                                                               \
      return retval;                                                    \
    }

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

Referenced by operator*().

#define SPARSE_FULL_TRANS_MUL	(		RET_TYPE,
			EL_TYPE,
			ZERO,
			CONJ_OP
	)

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

Referenced by herm_mul(), and trans_mul().

#define SPARSE_MSM_BIN_OP_1	(		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)                  \
      octave::err_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc);       \
    else                                                        \
      {                                                         \
        r = R (F (m1, m2.matrix_value ()));                     \
      }                                                         \
    return r;                                                   \
  }

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

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

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

#define SPARSE_MSM_BIN_OPS	(		R1,
			R2,
			M1,
			M2
	)

Value:

SPARSE_MSM_BIN_OP_1 (R1, operator +,  +, M1, M2)      \
  SPARSE_MSM_BIN_OP_1 (R1, operator -,  -, M1, M2)      \
  SPARSE_MSM_BIN_OP_2 (R2, product,     *, M1, M2)      \
  SPARSE_MSM_BIN_OP_1 (R2, quotient,    /, M1, M2)

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

#define SPARSE_MSM_BOOL_OP	(		F,
			OP,
			M1,
			M2,
			LHS_ZERO,
			RHS_ZERO
	)

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

#define SPARSE_MSM_BOOL_OPS	(		M1,
			M2,
			ZERO
	)		SPARSE_MSM_BOOL_OPS2(M1, M2, ZERO, ZERO)

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

#define SPARSE_MSM_BOOL_OPS2	(		M1,
			M2,
			LHS_ZERO,
			RHS_ZERO
	)

Value:

SPARSE_MSM_BOOL_OP (mx_el_and, &&, M1, M2, LHS_ZERO, RHS_ZERO)        \
  SPARSE_MSM_BOOL_OP (mx_el_or,  ||, M1, M2, LHS_ZERO, RHS_ZERO)

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

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

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

#define SPARSE_MSM_CMP_OPS	(		M1,
			Z1,
			C1,
			M2,
			Z2,
			C2
	)

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,   )

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

#define SPARSE_MSM_EQNE_OPS	(		M1,
			Z1,
			C1,
			M2,
			Z2,
			C2
	)

Value:

SPARSE_MSM_CMP_OP (mx_el_eq, ==, M1,   , M2,   )      \
  SPARSE_MSM_CMP_OP (mx_el_ne, !=, M1,   , M2,   )

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

#define SPARSE_REDUCTION_OP	(		RET_TYPE,
			EL_TYPE,
			OP,
			INIT_VAL,
			MT_RESULT
	)

Value:

SPARSE_BASE_REDUCTION_OP (RET_TYPE, EL_TYPE,                          \
                            SPARSE_REDUCTION_OP_ROW_EXPR (OP),          \
                            SPARSE_REDUCTION_OP_COL_EXPR (OP),          \
                            INIT_VAL, MT_RESULT)

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

Referenced by SparseMatrix::prod(), SparseComplexMatrix::prod(), SparseMatrix::sum(), and SparseComplexMatrix::sum().

#define SPARSE_REDUCTION_OP_COL_EXPR

(

OP

)

tmp[j] OP data (i)

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

#define SPARSE_REDUCTION_OP_ROW_EXPR

(

OP

)

tmp[ridx (i)] OP data (i)

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

#define SPARSE_SMM_BIN_OP_1	(		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)                  \
      octave::err_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc);       \
    else                                                        \
      {                                                         \
        r = R (m1.matrix_value () OP m2);                       \
      }                                                         \
    return r;                                                   \
  }

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

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

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

#define SPARSE_SMM_BIN_OP_2_CHECK_product

(

ET

)

do_mx_check (m2, mx_inline_all_finite<ET>)

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

#define SPARSE_SMM_BIN_OP_2_CHECK_quotient

(

ET

)

! do_mx_check (m2, mx_inline_any_nan<ET>) && m2.nnz () == m2.numel ()

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

#define SPARSE_SMM_BIN_OPS	(		R1,
			R2,
			M1,
			M2
	)

Value:

SPARSE_SMM_BIN_OP_1 (R1, operator +,  +, M1, M2)      \
  SPARSE_SMM_BIN_OP_1 (R1, operator -,  -, M1, M2)      \
  SPARSE_SMM_BIN_OP_2 (R2, product,     *, M1, M2)      \
  SPARSE_SMM_BIN_OP_2 (R2, quotient,    /, M1, M2)

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

#define SPARSE_SMM_BOOL_OP	(		F,
			OP,
			M1,
			M2,
			LHS_ZERO,
			RHS_ZERO
	)

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

#define SPARSE_SMM_BOOL_OPS	(		M1,
			M2,
			ZERO
	)		SPARSE_SMM_BOOL_OPS2(M1, M2, ZERO, ZERO)

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

#define SPARSE_SMM_BOOL_OPS2	(		M1,
			M2,
			LHS_ZERO,
			RHS_ZERO
	)

Value:

SPARSE_SMM_BOOL_OP (mx_el_and, &&, M1, M2, LHS_ZERO, RHS_ZERO)        \
  SPARSE_SMM_BOOL_OP (mx_el_or,  ||, M1, M2, LHS_ZERO, RHS_ZERO)

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

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

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

#define SPARSE_SMM_CMP_OPS	(		M1,
			Z1,
			C1,
			M2,
			Z2,
			C2
	)

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,   )

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

#define SPARSE_SMM_EQNE_OPS	(		M1,
			Z1,
			C1,
			M2,
			Z2,
			C2
	)

Value:

SPARSE_SMM_CMP_OP (mx_el_eq, ==, M1,   , M2,   )      \
  SPARSE_SMM_CMP_OP (mx_el_ne, !=, M1,   , M2,   )

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

#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;                                                           \
  }

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

#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 51 of file Sparse-op-defs.h.

#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)

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

#define SPARSE_SMS_BOOL_OP	(		F,
			OP,
			M,
			S,
			LHS_ZERO,
			RHS_ZERO
	)

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

#define SPARSE_SMS_BOOL_OPS	(		M,
			S,
			ZERO
	)		SPARSE_SMS_BOOL_OPS2(M, S, ZERO, ZERO)

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

#define SPARSE_SMS_BOOL_OPS2	(		M,
			S,
			LHS_ZERO,
			RHS_ZERO
	)

Value:

SPARSE_SMS_BOOL_OP (mx_el_and, &&, M, S, LHS_ZERO, RHS_ZERO)  \
  SPARSE_SMS_BOOL_OP (mx_el_or,  ||, M, S, LHS_ZERO, RHS_ZERO)

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

#define SPARSE_SMS_CMP_OP	(		F,
			OP,
			M,
			MZ,
			MC,
			S,
			SZ,
			SC
	)

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

#define SPARSE_SMS_CMP_OPS	(		M,
			MZ,
			CM,
			S,
			SZ,
			CS
	)

Value:

SPARSE_SMS_CMP_OP (mx_el_lt, <,  M, MZ,   , S, SZ,   )        \
  SPARSE_SMS_CMP_OP (mx_el_le, <=, M, MZ,   , S, SZ,   )        \
  SPARSE_SMS_CMP_OP (mx_el_ge, >=, M, MZ,   , S, SZ,   )        \
  SPARSE_SMS_CMP_OP (mx_el_gt, >,  M, MZ,   , S, SZ,   )        \
  SPARSE_SMS_CMP_OP (mx_el_eq, ==, M, MZ,   , S, SZ,   )        \
  SPARSE_SMS_CMP_OP (mx_el_ne, !=, M, MZ,   , S, SZ,   )

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

#define SPARSE_SMS_EQNE_OPS	(		M,
			MZ,
			CM,
			S,
			SZ,
			CS
	)

Value:

SPARSE_SMS_CMP_OP (mx_el_eq, ==, M, MZ,   , S, SZ,   )        \
  SPARSE_SMS_CMP_OP (mx_el_ne, !=, M, MZ,   , S, SZ,   )

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

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

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

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

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

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

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

#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)

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

#define SPARSE_SMSM_BOOL_OP	(		F,
			OP,
			M1,
			M2,
			LHS_ZERO,
			RHS_ZERO
	)

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

#define SPARSE_SMSM_BOOL_OPS	(		M1,
			M2,
			ZERO
	)		SPARSE_SMSM_BOOL_OPS2(M1, M2, ZERO, ZERO)

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

#define SPARSE_SMSM_BOOL_OPS2	(		M1,
			M2,
			LHS_ZERO,
			RHS_ZERO
	)

Value:

SPARSE_SMSM_BOOL_OP (mx_el_and, &&, M1, M2, LHS_ZERO, RHS_ZERO)       \
  SPARSE_SMSM_BOOL_OP (mx_el_or,  ||, M1, M2, LHS_ZERO, RHS_ZERO)

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

#define SPARSE_SMSM_CMP_OP	(		F,
			OP,
			M1,
			Z1,
			C1,
			M2,
			Z2,
			C2
	)

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

#define SPARSE_SMSM_CMP_OPS	(		M1,
			Z1,
			C1,
			M2,
			Z2,
			C2
	)

Value:

SPARSE_SMSM_CMP_OP (mx_el_lt, <,  M1, Z1,   , M2, Z2,   )     \
  SPARSE_SMSM_CMP_OP (mx_el_le, <=, M1, Z1,   , M2, Z2,   )     \
  SPARSE_SMSM_CMP_OP (mx_el_ge, >=, M1, Z1,   , M2, Z2,   )     \
  SPARSE_SMSM_CMP_OP (mx_el_gt, >,  M1, Z1,   , M2, Z2,   )     \
  SPARSE_SMSM_CMP_OP (mx_el_eq, ==, M1, Z1,   , M2, Z2,   )     \
  SPARSE_SMSM_CMP_OP (mx_el_ne, !=, M1, Z1,   , M2, Z2,   )

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

#define SPARSE_SMSM_EQNE_OPS	(		M1,
			Z1,
			C1,
			M2,
			Z2,
			C2
	)

Value:

SPARSE_SMSM_CMP_OP (mx_el_eq, ==, M1, Z1,   , M2, Z2,   )     \
  SPARSE_SMSM_CMP_OP (mx_el_ne, !=, M1, Z1,   , M2, Z2,   )

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

#define SPARSE_SPARSE_MUL	(		RET_TYPE,
			RET_EL_TYPE,
			EL_TYPE
	)

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

Referenced by operator*().

#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 177 of file Sparse-op-defs.h.

#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 193 of file Sparse-op-defs.h.

#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_2 (R2, operator /, /, S, M)

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

#define SPARSE_SSM_BOOL_OP	(		F,
			OP,
			S,
			M,
			LHS_ZERO,
			RHS_ZERO
	)

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

#define SPARSE_SSM_BOOL_OPS	(		S,
			M,
			ZERO
	)		SPARSE_SSM_BOOL_OPS2(S, M, ZERO, ZERO)

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

#define SPARSE_SSM_BOOL_OPS2	(		S,
			M,
			LHS_ZERO,
			RHS_ZERO
	)

Value:

SPARSE_SSM_BOOL_OP (mx_el_and, &&, S, M, LHS_ZERO, RHS_ZERO)  \
  SPARSE_SSM_BOOL_OP (mx_el_or,  ||, S, M, LHS_ZERO, RHS_ZERO)

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

#define SPARSE_SSM_CMP_OP	(		F,
			OP,
			S,
			SZ,
			SC,
			M,
			MZ,
			MC
	)

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

#define SPARSE_SSM_CMP_OPS	(		S,
			SZ,
			SC,
			M,
			MZ,
			MC
	)

Value:

SPARSE_SSM_CMP_OP (mx_el_lt, <,  S, SZ,   , M, MZ,   )        \
  SPARSE_SSM_CMP_OP (mx_el_le, <=, S, SZ,   , M, MZ,   )        \
  SPARSE_SSM_CMP_OP (mx_el_ge, >=, S, SZ,   , M, MZ,   )        \
  SPARSE_SSM_CMP_OP (mx_el_gt, >,  S, SZ,   , M, MZ,   )        \
  SPARSE_SSM_CMP_OP (mx_el_eq, ==, S, SZ,   , M, MZ,   )        \
  SPARSE_SSM_CMP_OP (mx_el_ne, !=, S, SZ,   , M, MZ,   )

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

#define SPARSE_SSM_EQNE_OPS	(		S,
			SZ,
			SC,
			M,
			MZ,
			MC
	)

Value:

SPARSE_SSM_CMP_OP (mx_el_eq, ==, S, SZ,   , M, MZ,   )        \
  SPARSE_SSM_CMP_OP (mx_el_ne, !=, S, SZ,   , M, MZ,   )

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