メインページ   クラス階層   構成   ファイル一覧   構成メンバ   ファイルメンバ  

mx-op-defs.h の解説

#include "mx-inlines.cc"

mx-op-defs.hのインクルード依存関係図

Include dependency graph

このグラフは、どのファイルから直接、間接的にインクルードされているかを示しています。

Included by dependency graph

ソースコードを見る。

マクロ定義

#define octave_mx_op_defs_h   1
#define BIN_OP_DECL(R, OP, X, Y)   extern R OP (const X&, const Y&)
#define CMP_OP_DECL(OP, X, Y)   extern boolMatrix OP (const X&, const Y&)
#define NDCMP_OP_DECL(OP, X, Y)   extern boolNDArray OP (const X&, const Y&)
#define BOOL_OP_DECL(OP, X, Y)   extern boolMatrix OP (const X&, const Y&)
#define NDBOOL_OP_DECL(OP, X, Y)   extern boolNDArray OP (const X&, const Y&)
#define VS_BIN_OP_DECLS(R, V, S)
#define VS_BIN_OP(R, F, OP, V, S)
#define VS_BIN_OPS(R, V, S)
#define VS_OP_DECLS(R, V, S)   VS_BIN_OP_DECLS(R, V, S)
#define SV_BIN_OP_DECLS(R, S, V)
#define SV_BIN_OP(R, F, OP, S, V)
#define SV_BIN_OPS(R, S, V)
#define SV_OP_DECLS(R, S, V)   SV_BIN_OP_DECLS(R, S, V)
#define VV_BIN_OP_DECLS(R, V1, V2)
#define VV_BIN_OP(R, F, OP, V1, V2)
#define VV_BIN_OPS(R, V1, V2)
#define VV_OP_DECLS(R, V1, V2)   VV_BIN_OP_DECLS(R, V1, V2)
#define MS_BIN_OP_DECLS(R, M, S)
#define MS_BIN_OP(R, OP, M, S, F)
#define MS_BIN_OPS(R, M, S)
#define MS_CMP_OP_DECLS(M, S)
#define MS_CMP_OP(F, OP, M, MC, S, SC)
#define MS_CMP_OPS(M, CM, S, CS)
#define MS_BOOL_OP_DECLS(M, S)
#define MS_BOOL_OP(F, OP, M, S, LHS_ZERO, RHS_ZERO)
#define MS_BOOL_OPS2(M, S, LHS_ZERO, RHS_ZERO)
#define MS_BOOL_OPS(M, S, ZERO)   MS_BOOL_OPS2(M, S, ZERO, ZERO)
#define MS_OP_DECLS(R, M, S)
#define SM_BIN_OP_DECLS(R, S, M)
#define SM_BIN_OP(R, OP, S, M, F)
#define SM_BIN_OPS(R, S, M)
#define SM_CMP_OP_DECLS(S, M)
#define SM_CMP_OP(F, OP, S, SC, M, MC)
#define SM_CMP_OPS(S, CS, M, CM)
#define SM_BOOL_OP_DECLS(S, M)
#define SM_BOOL_OP(F, OP, S, M, LHS_ZERO, RHS_ZERO)
#define SM_BOOL_OPS2(S, M, LHS_ZERO, RHS_ZERO)
#define SM_BOOL_OPS(S, M, ZERO)   SM_BOOL_OPS2(S, M, ZERO, ZERO)
#define SM_OP_DECLS(R, S, M)
#define MM_BIN_OP_DECLS(R, M1, M2)
#define MM_BIN_OP(R, OP, M1, M2, F)
#define MM_BIN_OPS(R, M1, M2)
#define MM_CMP_OP_DECLS(M1, M2)
#define MM_CMP_OP(F, OP, M1, C1, M2, C2)
#define MM_CMP_OPS(M1, C1, M2, C2)
#define MM_BOOL_OP_DECLS(M1, M2)
#define MM_BOOL_OP(F, OP, M1, M2, LHS_ZERO, RHS_ZERO)
#define MM_BOOL_OPS2(M1, M2, LHS_ZERO, RHS_ZERO)
#define MM_BOOL_OPS(M1, M2, ZERO)   MM_BOOL_OPS2(M1, M2, ZERO, ZERO)
#define MM_OP_DECLS(R, M1, M2)
#define NDS_BIN_OP_DECLS(R, ND, S)
#define NDS_BIN_OP(R, OP, ND, S, F)
#define NDS_BIN_OPS(R, ND, S)
#define NDS_CMP_OP_DECLS(ND, S)
#define NDS_CMP_OP(F, OP, ND, NDC, S, SC)
#define NDS_CMP_OPS(ND, NDC, S, SC)
#define NDS_BOOL_OP_DECLS(ND, S)
#define NDS_BOOL_OP(F, OP, ND, S, LHS_ZERO, RHS_ZERO)
#define NDS_BOOL_OPS2(ND, S, LHS_ZERO, RHS_ZERO)
#define NDS_BOOL_OPS(ND, S, ZERO)   NDS_BOOL_OPS2(ND, S, ZERO, ZERO)
#define NDS_OP_DECLS(R, ND, S)
#define SND_BIN_OP_DECLS(R, S, ND)
#define SND_BIN_OP(R, OP, S, ND, F)
#define SND_BIN_OPS(R, S, ND)
#define SND_CMP_OP_DECLS(S, ND)
#define SND_CMP_OP(F, OP, S, SC, ND, NDC)
#define SND_CMP_OPS(S, CS, ND, CND)
#define SND_BOOL_OP_DECLS(S, ND)
#define SND_BOOL_OP(F, OP, S, ND, LHS_ZERO, RHS_ZERO)
#define SND_BOOL_OPS2(S, ND, LHS_ZERO, RHS_ZERO)
#define SND_BOOL_OPS(S, ND, ZERO)   SND_BOOL_OPS2(S, ND, ZERO, ZERO)
#define SND_OP_DECLS(R, S, ND)
#define NDND_BIN_OP_DECLS(R, ND1, ND2)
#define NDND_BIN_OP(R, OP, ND1, ND2, F)
#define NDND_BIN_OPS(R, ND1, ND2)
#define NDND_CMP_OP_DECLS(ND1, ND2)
#define NDND_CMP_OP(F, OP, ND1, C1, ND2, C2)
#define NDND_CMP_OPS(ND1, C1, ND2, C2)
#define NDND_BOOL_OP_DECLS(ND1, ND2)
#define NDND_BOOL_OP(F, OP, ND1, ND2, LHS_ZERO, RHS_ZERO)
#define NDND_BOOL_OPS2(ND1, ND2, LHS_ZERO, RHS_ZERO)
#define NDND_BOOL_OPS(ND1, ND2, ZERO)   NDND_BOOL_OPS2(ND1, ND2, ZERO, ZERO)
#define NDND_OP_DECLS(R, ND1, ND2)
#define SDM_BIN_OP_DECLS(R, S, DM)
#define SDM_BIN_OP(R, OP, S, DM, OPEQ)
#define SDM_BIN_OPS(R, S, DM)
#define SDM_OP_DECLS(R, S, DM)   SDM_BIN_OP_DECLS(R, S, DM)
#define DMS_BIN_OP_DECLS(R, DM, S)
#define DMS_BIN_OP(R, OP, DM, S, SGN)
#define DMS_BIN_OPS(R, DM, S)
#define DMS_OP_DECLS(R, DM, S)   DMS_BIN_OP_DECLS(R, DM, S)
#define MDM_BIN_OP_DECLS(R, M, DM)
#define MDM_BIN_OP(R, OP, M, DM, OPEQ)
#define MDM_MULTIPLY_OP(R, M, DM, R_ZERO)
#define MDM_BIN_OPS(R, M, DM, R_ZERO)
#define MDM_OP_DECLS(R, M, DM)   MDM_BIN_OP_DECLS(R, M, DM)
#define DMM_BIN_OP_DECLS(R, DM, M)
#define DMM_BIN_OP(R, OP, DM, M, OPEQ, PREOP)
#define DMM_MULTIPLY_OP(R, DM, M, R_ZERO)
#define DMM_BIN_OPS(R, DM, M, R_ZERO)
#define DMM_OP_DECLS(R, DM, M)   DMM_BIN_OP_DECLS(R, DM, M)
#define DMDM_BIN_OP_DECLS(R, DM1, DM2)
#define DMDM_BIN_OP(R, OP, DM1, DM2, F)
#define DMDM_BIN_OPS(R, DM1, DM2)
#define DMDM_OP_DECLS(R, DM1, DM2)   DMDM_BIN_OP_DECLS (R, DM1, DM2)

マクロ定義の解説

#define BIN_OP_DECL (  R,
OP,
X,
Y    )     extern R OP (const X&, const Y&)
 

mx-op-defs.h の 28 行で定義されています。

#define BOOL_OP_DECL (  OP,
X,
Y    )     extern boolMatrix OP (const X&, const Y&)
 

mx-op-defs.h の 40 行で定義されています。

#define CMP_OP_DECL (  OP,
X,
Y    )     extern boolMatrix OP (const X&, const Y&)
 

mx-op-defs.h の 34 行で定義されています。

#define DMDM_BIN_OP (  R,
OP,
DM1,
DM2,
F    ) 
 

値:

R \
  OP (const DM1& dm1, const DM2& dm2) \
  { \
    R r; \
 \
    int dm1_nr = dm1.rows (); \
    int dm1_nc = dm1.cols (); \
 \
    int dm2_nr = dm2.rows (); \
    int dm2_nc = dm2.cols (); \
 \
    if (dm1_nr != dm2_nr || dm1_nc != dm2_nc) \
      gripe_nonconformant (#OP, dm1_nr, dm1_nc, dm2_nr, dm2_nc); \
    else \
      { \
        r.resize (dm1_nr, dm1_nc); \
 \
        if (dm1_nr > 0 && dm1_nc > 0) \
          F ## _vv (r.fortran_vec (), dm1.data (), dm2.data (), \
                    dm1_nr * dm2_nc); \
      } \
 \
    return r; \
  }

mx-op-defs.h の 1029 行で定義されています。

#define DMDM_BIN_OP_DECLS (  R,
DM1,
DM2    ) 
 

値:

BIN_OP_DECL (R, operator +, DM1, DM2); \
  BIN_OP_DECL (R, operator -, DM1, DM2); \
  BIN_OP_DECL (R, product, DM1, DM2);

mx-op-defs.h の 1024 行で定義されています。

#define DMDM_BIN_OPS (  R,
DM1,
DM2    ) 
 

値:

DMDM_BIN_OP (R, operator +, DM1, DM2, mx_inline_add) \
  DMDM_BIN_OP (R, operator -, DM1, DM2, mx_inline_subtract) \
  DMDM_BIN_OP (R, product,    DM1, DM2, mx_inline_multiply)

mx-op-defs.h の 1055 行で定義されています。

#define DMDM_OP_DECLS (  R,
DM1,
DM2    )     DMDM_BIN_OP_DECLS (R, DM1, DM2)
 

mx-op-defs.h の 1060 行で定義されています。

#define DMM_BIN_OP (  R,
OP,
DM,
M,
OPEQ,
PREOP    ) 
 

値:

R \
OP (const DM& dm, const M& m) \
{ \
  R r; \
 \
  int dm_nr = dm.rows (); \
  int dm_nc = dm.cols (); \
 \
  int m_nr = m.rows (); \
  int m_nc = m.cols (); \
 \
  if (dm_nr != m_nr || dm_nc != m_nc) \
    gripe_nonconformant (#OP, dm_nr, dm_nc, m_nr, m_nc); \
  else \
    { \
      if (m_nr > 0 && m_nc > 0) \
        { \
          r = R (PREOP m); \
 \
          int len = dm.length (); \
 \
          for (int i = 0; i < len; i++) \
            r.elem(i, i) OPEQ dm.elem(i, i); \
        } \
      else \
        r.resize (m_nr, m_nc); \
    } \
 \
  return r; \
}

mx-op-defs.h の 941 行で定義されています。

#define DMM_BIN_OP_DECLS (  R,
DM,
M    ) 
 

値:

BIN_OP_DECL (R, operator +, DM, M); \
  BIN_OP_DECL (R, operator -, DM, M); \
  BIN_OP_DECL (R, operator *, DM, M);

mx-op-defs.h の 936 行で定義されています。

#define DMM_BIN_OPS (  R,
DM,
M,
R_ZERO    ) 
 

値:

DMM_BIN_OP (R, operator +, DM, M, +=, ) \
  DMM_BIN_OP (R, operator -, DM, M, +=, -) \
  DMM_MULTIPLY_OP (R, DM, M, R_ZERO)

mx-op-defs.h の 1014 行で定義されています。

#define DMM_MULTIPLY_OP (  R,
DM,
M,
R_ZERO    ) 
 

mx-op-defs.h の 973 行で定義されています。

#define DMM_OP_DECLS (  R,
DM,
M    )     DMM_BIN_OP_DECLS(R, DM, M)
 

mx-op-defs.h の 1019 行で定義されています。

#define DMS_BIN_OP (  R,
OP,
DM,
S,
SGN    ) 
 

値:

R \
  OP (const DM& dm, const S& s) \
  { \
    int nr = dm.rows (); \
    int nc = dm.cols (); \
 \
    R r (nr, nc, SGN s); \
 \
    for (int i = 0; i < dm.length (); i++) \
      r.elem(i, i) += dm.elem(i, i); \
 \
    return r; \
  }

mx-op-defs.h の 824 行で定義されています。

#define DMS_BIN_OP_DECLS (  R,
DM,
S    ) 
 

値:

BIN_OP_DECL (R, operator +, DM, S); \
  BIN_OP_DECL (R, operator -, DM, S);

mx-op-defs.h の 820 行で定義されています。

#define DMS_BIN_OPS (  R,
DM,
S    ) 
 

値:

DMS_BIN_OP (R, operator +, DM, S, ) \
  DMS_BIN_OP (R, operator -, DM, S, -)

mx-op-defs.h の 839 行で定義されています。

#define DMS_OP_DECLS (  R,
DM,
S    )     DMS_BIN_OP_DECLS(R, DM, S)
 

mx-op-defs.h の 843 行で定義されています。

#define MDM_BIN_OP (  R,
OP,
M,
DM,
OPEQ    ) 
 

値:

R \
OP (const M& m, const DM& dm) \
{ \
  R r; \
 \
  int m_nr = m.rows (); \
  int m_nc = m.cols (); \
 \
  int dm_nr = dm.rows (); \
  int dm_nc = dm.cols (); \
 \
  if (m_nr != dm_nr || m_nc != dm_nc) \
    gripe_nonconformant (#OP, m_nr, m_nc, dm_nr, dm_nc); \
  else \
    { \
      r.resize (m_nr, m_nc); \
 \
      if (m_nr > 0 && m_nc > 0) \
        { \
          r = R (m); \
 \
          int len = dm.length (); \
 \
          for (int i = 0; i < len; i++) \
            r.elem(i, i) OPEQ dm.elem(i, i); \
        } \
    } \
 \
  return r; \
}

mx-op-defs.h の 853 行で定義されています。

#define MDM_BIN_OP_DECLS (  R,
M,
DM    ) 
 

値:

BIN_OP_DECL (R, operator +, M, DM); \
  BIN_OP_DECL (R, operator -, M, DM); \
  BIN_OP_DECL (R, operator *, M, DM);

mx-op-defs.h の 848 行で定義されています。

#define MDM_BIN_OPS (  R,
M,
DM,
R_ZERO    ) 
 

値:

MDM_BIN_OP (R, operator +, M, DM, +=) \
  MDM_BIN_OP (R, operator -, M, DM, -=) \
  MDM_MULTIPLY_OP (R, M, DM, R_ZERO)

mx-op-defs.h の 926 行で定義されています。

#define MDM_MULTIPLY_OP (  R,
M,
DM,
R_ZERO    ) 
 

mx-op-defs.h の 885 行で定義されています。

#define MDM_OP_DECLS (  R,
M,
DM    )     MDM_BIN_OP_DECLS(R, M, DM)
 

mx-op-defs.h の 931 行で定義されています。

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

値:

R \
  OP (const M1& m1, const M2& m2) \
  { \
    R r; \
 \
    int m1_nr = m1.rows (); \
    int m1_nc = m1.cols (); \
 \
    int m2_nr = m2.rows (); \
    int m2_nc = m2.cols (); \
 \
    if (m1_nr != m2_nr || m1_nc != m2_nc) \
      gripe_nonconformant (#OP, m1_nr, m1_nc, m2_nr, m2_nc); \
    else \
      { \
        r.resize (m1_nr, m1_nc); \
 \
        if (m1_nr > 0 && m1_nc > 0) \
          F ## _vv (r.fortran_vec (), m1.data (), m2.data (), m1_nr * m1_nc); \
      } \
 \
    return r; \
  }

mx-op-defs.h の 361 行で定義されています。

#define MM_BIN_OP_DECLS (  R,
M1,
M2    ) 
 

値:

BIN_OP_DECL (R, operator +, M1, M2); \
  BIN_OP_DECL (R, operator -, M1, M2); \
  BIN_OP_DECL (R, product,    M1, M2); \
  BIN_OP_DECL (R, quotient,   M1, M2);

mx-op-defs.h の 355 行で定義されています。

#define MM_BIN_OPS (  R,
M1,
M2    ) 
 

値:

MM_BIN_OP (R, operator +, M1, M2, mx_inline_add) \
  MM_BIN_OP (R, operator -, M1, M2, mx_inline_subtract) \
  MM_BIN_OP (R, product,    M1, M2, mx_inline_multiply) \
  MM_BIN_OP (R, quotient,   M1, M2, mx_inline_divide)

mx-op-defs.h の 386 行で定義されています。

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

mx-op-defs.h の 438 行で定義されています。

#define MM_BOOL_OP_DECLS (  M1,
M2    ) 
 

値:

BOOL_OP_DECL (mx_el_and, M1, M2); \
  BOOL_OP_DECL (mx_el_or,  M1, M2);

mx-op-defs.h の 434 行で定義されています。

#define MM_BOOL_OPS (  M1,
M2,
ZERO    )     MM_BOOL_OPS2(M1, M2, ZERO, ZERO)
 

mx-op-defs.h の 475 行で定義されています。

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

値:

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

mx-op-defs.h の 471 行で定義されています。

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

値:

boolMatrix \
  F (const M1& m1, const M2& m2) \
  { \
    boolMatrix r; \
 \
    int m1_nr = m1.rows (); \
    int m1_nc = m1.cols (); \
 \
    int m2_nr = m2.rows (); \
    int m2_nc = m2.cols (); \
 \
    if (m1_nr == m2_nr && m1_nc == m2_nc) \
      { \
        r.resize (m1_nr, m1_nc); \
 \
        for (int j = 0; j < m1_nc; j++) \
          for (int i = 0; i < m1_nr; i++) \
            r.elem(i, j) = C1 (m1.elem(i, j)) OP C2 (m2.elem(i, j)); \
      } \
    else \
      gripe_nonconformant (#F, m1_nr, m1_nc, m2_nr, m2_nc); \
 \
    return r; \
  }

mx-op-defs.h の 400 行で定義されています。

#define MM_CMP_OP_DECLS (  M1,
M2    ) 
 

値:

CMP_OP_DECL (mx_el_lt, M1, M2); \
  CMP_OP_DECL (mx_el_le, M1, M2); \
  CMP_OP_DECL (mx_el_ge, M1, M2); \
  CMP_OP_DECL (mx_el_gt, M1, M2); \
  CMP_OP_DECL (mx_el_eq, M1, M2); \
  CMP_OP_DECL (mx_el_ne, M1, M2);

mx-op-defs.h の 392 行で定義されています。

#define MM_CMP_OPS (  M1,
C1,
M2,
C2    ) 
 

値:

MM_CMP_OP (mx_el_lt, <,  M1, C1, M2, C2) \
  MM_CMP_OP (mx_el_le, <=, M1, C1, M2, C2) \
  MM_CMP_OP (mx_el_ge, >=, M1, C1, M2, C2) \
  MM_CMP_OP (mx_el_gt, >,  M1, C1, M2, C2) \
  MM_CMP_OP (mx_el_eq, ==, M1,   , M2,   ) \
  MM_CMP_OP (mx_el_ne, !=, M1,   , M2,   )

mx-op-defs.h の 426 行で定義されています。

#define MM_OP_DECLS (  R,
M1,
M2    ) 
 

値:

MM_BIN_OP_DECLS (R, M1, M2) \
  MM_CMP_OP_DECLS (M1, M2) \
  MM_BOOL_OP_DECLS (M1, M2)

mx-op-defs.h の 478 行で定義されています。

#define MS_BIN_OP (  R,
OP,
M,
S,
F    ) 
 

値:

R \
  OP (const M& m, const S& s) \
  { \
    int nr = m.rows (); \
    int nc = m.cols (); \
 \
    R r (nr, nc); \
 \
    if (nr > 0 && nc > 0) \
      F ## _vs (r.fortran_vec (), m.data (), nr * nc, s); \
 \
    return r; \
  }

mx-op-defs.h の 155 行で定義されています。

#define MS_BIN_OP_DECLS (  R,
M,
S    ) 
 

値:

BIN_OP_DECL (R, operator +, M, S); \
  BIN_OP_DECL (R, operator -, M, S); \
  BIN_OP_DECL (R, operator *, M, S); \
  BIN_OP_DECL (R, operator /, M, S);

mx-op-defs.h の 149 行で定義されています。

#define MS_BIN_OPS (  R,
M,
S    ) 
 

値:

MS_BIN_OP (R, operator +, M, S, mx_inline_add) \
  MS_BIN_OP (R, operator -, M, S, mx_inline_subtract) \
  MS_BIN_OP (R, operator *, M, S, mx_inline_multiply) \
  MS_BIN_OP (R, operator /, M, S, mx_inline_divide)

mx-op-defs.h の 170 行で定義されています。

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

値:

boolMatrix \
  F (const M& m, const S& s) \
  { \
    boolMatrix r; \
 \
    int nr = m.rows (); \
    int nc = m.cols (); \
 \
    if (nr != 0 && nc != 0) \
      { \
        r.resize (nr, nc); \
 \
        for (int j = 0; j < nc; j++) \
          for (int i = 0; i < nr; i++) \
            r.elem(i, j) = (m.elem(i, j) != LHS_ZERO) OP (s != RHS_ZERO); \
      } \
 \
    return r; \
  }

mx-op-defs.h の 217 行で定義されています。

#define MS_BOOL_OP_DECLS (  M,
S    ) 
 

値:

BOOL_OP_DECL (mx_el_and, M, S); \
  BOOL_OP_DECL (mx_el_or,  M, S); \

mx-op-defs.h の 213 行で定義されています。

#define MS_BOOL_OPS (  M,
S,
ZERO    )     MS_BOOL_OPS2(M, S, ZERO, ZERO)
 

mx-op-defs.h の 242 行で定義されています。

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

値:

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

mx-op-defs.h の 238 行で定義されています。

#define MS_CMP_OP (  F,
OP,
M,
MC,
S,
SC    ) 
 

値:

boolMatrix \
  F (const M& m, const S& s) \
  { \
    boolMatrix r; \
 \
    int nr = m.rows (); \
    int nc = m.cols (); \
 \
    r.resize (nr, nc); \
 \
    if (nr > 0 && nc > 0) \
      { \
        for (int j = 0; j < nc; j++) \
          for (int i = 0; i < nr; i++) \
            r.elem(i, j) = MC (m.elem(i, j)) OP SC (s); \
      } \
 \
    return r; \
  }

mx-op-defs.h の 184 行で定義されています。

#define MS_CMP_OP_DECLS (  M,
S    ) 
 

値:

CMP_OP_DECL (mx_el_lt, M, S); \
  CMP_OP_DECL (mx_el_le, M, S); \
  CMP_OP_DECL (mx_el_ge, M, S); \
  CMP_OP_DECL (mx_el_gt, M, S); \
  CMP_OP_DECL (mx_el_eq, M, S); \
  CMP_OP_DECL (mx_el_ne, M, S);

mx-op-defs.h の 176 行で定義されています。

#define MS_CMP_OPS (  M,
CM,
S,
CS    ) 
 

値:

MS_CMP_OP (mx_el_lt, <,  M, CM, S, CS) \
  MS_CMP_OP (mx_el_le, <=, M, CM, S, CS) \
  MS_CMP_OP (mx_el_ge, >=, M, CM, S, CS) \
  MS_CMP_OP (mx_el_gt, >,  M, CM, S, CS) \
  MS_CMP_OP (mx_el_eq, ==, M,   , S,   ) \
  MS_CMP_OP (mx_el_ne, !=, M,   , S,   )

mx-op-defs.h の 205 行で定義されています。

#define MS_OP_DECLS (  R,
M,
S    ) 
 

値:

MS_BIN_OP_DECLS (R, M, S) \
  MS_CMP_OP_DECLS (M, S) \
  MS_BOOL_OP_DECLS (M, S) \

mx-op-defs.h の 245 行で定義されています。

#define NDBOOL_OP_DECL (  OP,
X,
Y    )     extern boolNDArray OP (const X&, const Y&)
 

mx-op-defs.h の 43 行で定義されています。

#define NDCMP_OP_DECL (  OP,
X,
Y    )     extern boolNDArray OP (const X&, const Y&)
 

mx-op-defs.h の 37 行で定義されています。

#define NDND_BIN_OP (  R,
OP,
ND1,
ND2,
F    ) 
 

値:

R \
  OP (const ND1& m1, const ND2& m2) \
  { \
    R r; \
 \
    dim_vector m1_dims = m1.dims (); \
    dim_vector m2_dims = m2.dims (); \
 \
    if (m1_dims != m2_dims) \
      gripe_nonconformant (#OP, m1_dims, m2_dims); \
    else \
      { \
        r.resize (m1_dims); \
 \
        int len = m1.length (); \
 \
        if (len > 0) \
          F ## _vv (r.fortran_vec (), m1.data (), m2.data (), len); \
      } \
 \
    return r; \
  }

mx-op-defs.h の 681 行で定義されています。

#define NDND_BIN_OP_DECLS (  R,
ND1,
ND2    ) 
 

値:

BIN_OP_DECL (R, operator +, ND1, ND2); \
  BIN_OP_DECL (R, operator -, ND1, ND2); \
  BIN_OP_DECL (R, product,    ND1, ND2); \
  BIN_OP_DECL (R, quotient,   ND1, ND2);

mx-op-defs.h の 675 行で定義されています。

#define NDND_BIN_OPS (  R,
ND1,
ND2    ) 
 

値:

NDND_BIN_OP (R, operator +, ND1, ND2, mx_inline_add) \
  NDND_BIN_OP (R, operator -, ND1, ND2, mx_inline_subtract) \
  NDND_BIN_OP (R, product,    ND1, ND2, mx_inline_multiply) \
  NDND_BIN_OP (R, quotient,   ND1, ND2, mx_inline_divide)

mx-op-defs.h の 705 行で定義されています。

#define NDND_BOOL_OP (  F,
OP,
ND1,
ND2,
LHS_ZERO,
RHS_ZERO    ) 
 

値:

boolNDArray \
  F (const ND1& m1, const ND2& m2) \
  { \
    boolNDArray r; \
 \
    dim_vector m1_dims = m1.dims (); \
    dim_vector m2_dims = m2.dims (); \
 \
    if (m1_dims == m2_dims) \
      { \
        if (! m1_dims.all_zero ()) \
          { \
            r.resize (m1_dims); \
 \
            for (int i = 0; i < m1.length (); i++) \
              r.elem(i) = (m1.elem(i) != LHS_ZERO) OP (m2.elem(i) != RHS_ZERO); \
          } \
      } \
    else \
      gripe_nonconformant (#F, m1_dims, m2_dims); \
 \
    return r; \
  }

mx-op-defs.h の 753 行で定義されています。

#define NDND_BOOL_OP_DECLS (  ND1,
ND2    ) 
 

値:

NDBOOL_OP_DECL (mx_el_and, ND1, ND2); \
  NDBOOL_OP_DECL (mx_el_or,  ND1, ND2);

mx-op-defs.h の 749 行で定義されています。

#define NDND_BOOL_OPS (  ND1,
ND2,
ZERO    )     NDND_BOOL_OPS2(ND1, ND2, ZERO, ZERO)
 

mx-op-defs.h の 782 行で定義されています。

#define NDND_BOOL_OPS2 (  ND1,
ND2,
LHS_ZERO,
RHS_ZERO    ) 
 

値:

NDND_BOOL_OP (mx_el_and, &&, ND1, ND2, LHS_ZERO, RHS_ZERO) \
  NDND_BOOL_OP (mx_el_or,  ||, ND1, ND2, LHS_ZERO, RHS_ZERO)

mx-op-defs.h の 778 行で定義されています。

#define NDND_CMP_OP (  F,
OP,
ND1,
C1,
ND2,
C2    ) 
 

値:

boolNDArray \
  F (const ND1& m1, const ND2& m2) \
  { \
    boolNDArray r; \
 \
    dim_vector m1_dims = m1.dims (); \
    dim_vector m2_dims = m2.dims (); \
 \
    if (m1_dims == m2_dims) \
      { \
        r.resize (m1_dims); \
 \
        for (int i = 0; i < m1.length (); i++) \
          r.elem(i) = C1 (m1.elem(i)) OP C2 (m2.elem(i)); \
      } \
    else \
      gripe_nonconformant (#F, m1_dims, m2_dims); \
 \
    return r; \
  }

mx-op-defs.h の 719 行で定義されています。

#define NDND_CMP_OP_DECLS (  ND1,
ND2    ) 
 

値:

NDCMP_OP_DECL (mx_el_lt, ND1, ND2); \
  NDCMP_OP_DECL (mx_el_le, ND1, ND2); \
  NDCMP_OP_DECL (mx_el_ge, ND1, ND2); \
  NDCMP_OP_DECL (mx_el_gt, ND1, ND2); \
  NDCMP_OP_DECL (mx_el_eq, ND1, ND2); \
  NDCMP_OP_DECL (mx_el_ne, ND1, ND2);

mx-op-defs.h の 711 行で定義されています。

#define NDND_CMP_OPS (  ND1,
C1,
ND2,
C2    ) 
 

値:

NDND_CMP_OP (mx_el_lt, <,  ND1, C1, ND2, C2) \
  NDND_CMP_OP (mx_el_le, <=, ND1, C1, ND2, C2) \
  NDND_CMP_OP (mx_el_ge, >=, ND1, C1, ND2, C2) \
  NDND_CMP_OP (mx_el_gt, >,  ND1, C1, ND2, C2) \
  NDND_CMP_OP (mx_el_eq, ==, ND1,   , ND2,   ) \
  NDND_CMP_OP (mx_el_ne, !=, ND1,   , ND2,   )

mx-op-defs.h の 741 行で定義されています。

#define NDND_OP_DECLS (  R,
ND1,
ND2    ) 
 

値:

NDND_BIN_OP_DECLS (R, ND1, ND2) \
  NDND_CMP_OP_DECLS (ND1, ND2) \
  NDND_BOOL_OP_DECLS (ND1, ND2)

mx-op-defs.h の 785 行で定義されています。

#define NDS_BIN_OP (  R,
OP,
ND,
S,
F    ) 
 

値:

R \
  OP (const ND& m, const S& s) \
  { \
    R r (m.dims ()); \
 \
    int len = m.length (); \
 \
    if (len > 0) \
      F ## _vs (r.fortran_vec (), m.data (), len, s); \
 \
    return r; \
  }

mx-op-defs.h の 491 行で定義されています。

#define NDS_BIN_OP_DECLS (  R,
ND,
S    ) 
 

値:

BIN_OP_DECL (R, operator +, ND, S); \
  BIN_OP_DECL (R, operator -, ND, S); \
  BIN_OP_DECL (R, operator *, ND, S); \
  BIN_OP_DECL (R, operator /, ND, S);

mx-op-defs.h の 485 行で定義されています。

#define NDS_BIN_OPS (  R,
ND,
S    ) 
 

値:

NDS_BIN_OP (R, operator +, ND, S, mx_inline_add) \
  NDS_BIN_OP (R, operator -, ND, S, mx_inline_subtract) \
  NDS_BIN_OP (R, operator *, ND, S, mx_inline_multiply) \
  NDS_BIN_OP (R, operator /, ND, S, mx_inline_divide)

mx-op-defs.h の 505 行で定義されています。

#define NDS_BOOL_OP (  F,
OP,
ND,
S,
LHS_ZERO,
RHS_ZERO    ) 
 

値:

boolNDArray \
  F (const ND& m, const S& s) \
  { \
    boolNDArray r; \
 \
    int len = m.length (); \
 \
    if (len > 0) \
      { \
        r.resize (m.dims ()); \
 \
        for (int i = 0; i < len; i++) \
          r.elem(i) = (m.elem(i) != LHS_ZERO) OP (s != RHS_ZERO); \
      } \
 \
    return r; \
  }

mx-op-defs.h の 547 行で定義されています。

#define NDS_BOOL_OP_DECLS (  ND,
S    ) 
 

値:

NDBOOL_OP_DECL (mx_el_and, ND, S); \
  NDBOOL_OP_DECL (mx_el_or,  ND, S);

mx-op-defs.h の 543 行で定義されています。

#define NDS_BOOL_OPS (  ND,
S,
ZERO    )     NDS_BOOL_OPS2(ND, S, ZERO, ZERO)
 

mx-op-defs.h の 570 行で定義されています。

#define NDS_BOOL_OPS2 (  ND,
S,
LHS_ZERO,
RHS_ZERO    ) 
 

値:

NDS_BOOL_OP (mx_el_and, &&, ND, S, LHS_ZERO, RHS_ZERO) \
  NDS_BOOL_OP (mx_el_or,  ||, ND, S, LHS_ZERO, RHS_ZERO)

mx-op-defs.h の 566 行で定義されています。

#define NDS_CMP_OP (  F,
OP,
ND,
NDC,
S,
SC    ) 
 

値:

boolNDArray \
  F (const ND& m, const S& s) \
  { \
    boolNDArray r; \
 \
    int len = m.length (); \
 \
    r.resize (m.dims ()); \
 \
    for (int i = 0; i < len; i++) \
      r.elem(i) = NDC (m.elem(i)) OP SC (s); \
 \
    return r; \
  }

mx-op-defs.h の 519 行で定義されています。

#define NDS_CMP_OP_DECLS (  ND,
S    ) 
 

値:

NDCMP_OP_DECL (mx_el_lt, ND, S); \
  NDCMP_OP_DECL (mx_el_le, ND, S); \
  NDCMP_OP_DECL (mx_el_ge, ND, S); \
  NDCMP_OP_DECL (mx_el_gt, ND, S); \
  NDCMP_OP_DECL (mx_el_eq, ND, S); \
  NDCMP_OP_DECL (mx_el_ne, ND, S);

mx-op-defs.h の 511 行で定義されています。

#define NDS_CMP_OPS (  ND,
NDC,
S,
SC    ) 
 

値:

NDS_CMP_OP (mx_el_lt, <,  ND, NDC, S, SC) \
  NDS_CMP_OP (mx_el_le, <=, ND, NDC, S, SC) \
  NDS_CMP_OP (mx_el_ge, >=, ND, NDC, S, SC) \
  NDS_CMP_OP (mx_el_gt, >,  ND, NDC, S, SC) \
  NDS_CMP_OP (mx_el_eq, ==, ND,    , S,   ) \
  NDS_CMP_OP (mx_el_ne, !=, ND,    , S,   )

mx-op-defs.h の 535 行で定義されています。

#define NDS_OP_DECLS (  R,
ND,
S    ) 
 

値:

NDS_BIN_OP_DECLS (R, ND, S) \
  NDS_CMP_OP_DECLS (ND, S) \
  NDS_BOOL_OP_DECLS (ND, S)

mx-op-defs.h の 573 行で定義されています。

#define octave_mx_op_defs_h   1
 

mx-op-defs.h の 24 行で定義されています。

#define SDM_BIN_OP (  R,
OP,
S,
DM,
OPEQ    ) 
 

値:

R \
  OP (const S& s, const DM& dm) \
  { \
    int nr = dm.rows (); \
    int nc = dm.cols (); \
 \
    R r (nr, nc, s); \
 \
    for (int i = 0; i < dm.length (); i++) \
      r.elem(i, i) OPEQ dm.elem(i, i); \
 \
    return r; \
}

mx-op-defs.h の 796 行で定義されています。

#define SDM_BIN_OP_DECLS (  R,
S,
DM    ) 
 

値:

BIN_OP_DECL (R, operator +, S, DM); \
  BIN_OP_DECL (R, operator -, S, DM);

mx-op-defs.h の 792 行で定義されています。

#define SDM_BIN_OPS (  R,
S,
DM    ) 
 

値:

SDM_BIN_OP (R, operator +, S, DM, +=) \
  SDM_BIN_OP (R, operator -, S, DM, -=)

mx-op-defs.h の 811 行で定義されています。

#define SDM_OP_DECLS (  R,
S,
DM    )     SDM_BIN_OP_DECLS(R, S, DM)
 

mx-op-defs.h の 815 行で定義されています。

#define SM_BIN_OP (  R,
OP,
S,
M,
F    ) 
 

値:

R \
  OP (const S& s, const M& m) \
  { \
    int nr = m.rows (); \
    int nc = m.cols (); \
 \
    R r (nr, nc); \
 \
    if (nr > 0 && nc > 0) \
      F ## _sv (r.fortran_vec (), s, m.data (), nr * nc); \
 \
    return r; \
  }

mx-op-defs.h の 258 行で定義されています。

#define SM_BIN_OP_DECLS (  R,
S,
M    ) 
 

値:

BIN_OP_DECL (R, operator +, S, M); \
  BIN_OP_DECL (R, operator -, S, M); \
  BIN_OP_DECL (R, operator *, S, M); \
  BIN_OP_DECL (R, operator /, S, M);

mx-op-defs.h の 252 行で定義されています。

#define SM_BIN_OPS (  R,
S,
M    ) 
 

値:

SM_BIN_OP (R, operator +, S, M, mx_inline_add) \
  SM_BIN_OP (R, operator -, S, M, mx_inline_subtract) \
  SM_BIN_OP (R, operator *, S, M, mx_inline_multiply) \
  SM_BIN_OP (R, operator /, S, M, mx_inline_divide)

mx-op-defs.h の 273 行で定義されています。

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

値:

boolMatrix \
  F (const S& s, const M& m) \
  { \
    boolMatrix r; \
 \
    int nr = m.rows (); \
    int nc = m.cols (); \
 \
    if (nr != 0 && nc != 0) \
      { \
        r.resize (nr, nc); \
 \
        for (int j = 0; j < nc; j++) \
          for (int i = 0; i < nr; i++) \
            r.elem(i, j) = (s != LHS_ZERO) OP (m.elem(i, j) != RHS_ZERO); \
      } \
 \
    return r; \
  }

mx-op-defs.h の 320 行で定義されています。

#define SM_BOOL_OP_DECLS (  S,
M    ) 
 

値:

BOOL_OP_DECL (mx_el_and, S, M); \
  BOOL_OP_DECL (mx_el_or,  S, M); \

mx-op-defs.h の 316 行で定義されています。

#define SM_BOOL_OPS (  S,
M,
ZERO    )     SM_BOOL_OPS2(S, M, ZERO, ZERO)
 

mx-op-defs.h の 345 行で定義されています。

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

値:

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

mx-op-defs.h の 341 行で定義されています。

#define SM_CMP_OP (  F,
OP,
S,
SC,
M,
MC    ) 
 

値:

boolMatrix \
  F (const S& s, const M& m) \
  { \
    boolMatrix r; \
 \
    int nr = m.rows (); \
    int nc = m.cols (); \
 \
    r.resize (nr, nc); \
 \
    if (nr > 0 && nc > 0) \
      { \
        for (int j = 0; j < nc; j++) \
          for (int i = 0; i < nr; i++) \
            r.elem(i, j) = SC (s) OP MC (m.elem(i, j)); \
      } \
 \
    return r; \
  }

mx-op-defs.h の 287 行で定義されています。

#define SM_CMP_OP_DECLS (  S,
M    ) 
 

値:

CMP_OP_DECL (mx_el_lt, S, M); \
  CMP_OP_DECL (mx_el_le, S, M); \
  CMP_OP_DECL (mx_el_ge, S, M); \
  CMP_OP_DECL (mx_el_gt, S, M); \
  CMP_OP_DECL (mx_el_eq, S, M); \
  CMP_OP_DECL (mx_el_ne, S, M);

mx-op-defs.h の 279 行で定義されています。

#define SM_CMP_OPS (  S,
CS,
M,
CM    ) 
 

値:

SM_CMP_OP (mx_el_lt, <,  S, CS, M, CM) \
  SM_CMP_OP (mx_el_le, <=, S, CS, M, CM) \
  SM_CMP_OP (mx_el_ge, >=, S, CS, M, CM) \
  SM_CMP_OP (mx_el_gt, >,  S, CS, M, CM) \
  SM_CMP_OP (mx_el_eq, ==, S,   , M,   ) \
  SM_CMP_OP (mx_el_ne, !=, S,   , M,   )

mx-op-defs.h の 308 行で定義されています。

#define SM_OP_DECLS (  R,
S,
M    ) 
 

値:

SM_BIN_OP_DECLS (R, S, M) \
  SM_CMP_OP_DECLS (S, M) \
  SM_BOOL_OP_DECLS (S, M) \

mx-op-defs.h の 348 行で定義されています。

#define SND_BIN_OP (  R,
OP,
S,
ND,
F    ) 
 

値:

R \
  OP (const S& s, const ND& m) \
  { \
    R r (m.dims ()); \
 \
    int len = m.length (); \
 \
    if (len > 0) \
      F ## _sv (r.fortran_vec (), s, m.data (), len); \
 \
    return r; \
  }

mx-op-defs.h の 586 行で定義されています。

#define SND_BIN_OP_DECLS (  R,
S,
ND    ) 
 

値:

BIN_OP_DECL (R, operator +, S, ND); \
  BIN_OP_DECL (R, operator -, S, ND); \
  BIN_OP_DECL (R, operator *, S, ND); \
  BIN_OP_DECL (R, operator /, S, ND);

mx-op-defs.h の 580 行で定義されています。

#define SND_BIN_OPS (  R,
S,
ND    ) 
 

値:

SND_BIN_OP (R, operator +, S, ND, mx_inline_add) \
  SND_BIN_OP (R, operator -, S, ND, mx_inline_subtract) \
  SND_BIN_OP (R, operator *, S, ND, mx_inline_multiply) \
  SND_BIN_OP (R, operator /, S, ND, mx_inline_divide)

mx-op-defs.h の 600 行で定義されています。

#define SND_BOOL_OP (  F,
OP,
S,
ND,
LHS_ZERO,
RHS_ZERO    ) 
 

値:

boolNDArray \
  F (const S& s, const ND& m) \
  { \
    boolNDArray r; \
 \
    int len = m.length (); \
 \
    if (len > 0) \
      { \
        r.resize (m.dims ()); \
 \
        for (int i = 0; i < len; i++) \
            r.elem(i) = (s != LHS_ZERO) OP (m.elem(i) != RHS_ZERO); \
      } \
 \
    return r; \
  }

mx-op-defs.h の 642 行で定義されています。

#define SND_BOOL_OP_DECLS (  S,
ND    ) 
 

値:

NDBOOL_OP_DECL (mx_el_and, S, ND); \
  NDBOOL_OP_DECL (mx_el_or,  S, ND);

mx-op-defs.h の 638 行で定義されています。

#define SND_BOOL_OPS (  S,
ND,
ZERO    )     SND_BOOL_OPS2(S, ND, ZERO, ZERO)
 

mx-op-defs.h の 665 行で定義されています。

#define SND_BOOL_OPS2 (  S,
ND,
LHS_ZERO,
RHS_ZERO    ) 
 

値:

SND_BOOL_OP (mx_el_and, &&, S, ND, LHS_ZERO, RHS_ZERO) \
  SND_BOOL_OP (mx_el_or,  ||, S, ND, LHS_ZERO, RHS_ZERO)

mx-op-defs.h の 661 行で定義されています。

#define SND_CMP_OP (  F,
OP,
S,
SC,
ND,
NDC    ) 
 

値:

boolNDArray \
  F (const S& s, const ND& m) \
  { \
    boolNDArray r; \
 \
    int len = m.length (); \
 \
    r.resize (m.dims ()); \
 \
    for (int i = 0; i < len; i++) \
      r.elem(i) = SC (s) OP NDC (m.elem(i)); \
 \
    return r; \
  }

mx-op-defs.h の 614 行で定義されています。

#define SND_CMP_OP_DECLS (  S,
ND    ) 
 

値:

NDCMP_OP_DECL (mx_el_lt, S, ND); \
  NDCMP_OP_DECL (mx_el_le, S, ND); \
  NDCMP_OP_DECL (mx_el_ge, S, ND); \
  NDCMP_OP_DECL (mx_el_gt, S, ND); \
  NDCMP_OP_DECL (mx_el_eq, S, ND); \
  NDCMP_OP_DECL (mx_el_ne, S, ND);

mx-op-defs.h の 606 行で定義されています。

#define SND_CMP_OPS (  S,
CS,
ND,
CND    ) 
 

値:

SND_CMP_OP (mx_el_lt, <,  S, CS, ND, CND) \
  SND_CMP_OP (mx_el_le, <=, S, CS, ND, CND) \
  SND_CMP_OP (mx_el_ge, >=, S, CS, ND, CND) \
  SND_CMP_OP (mx_el_gt, >,  S, CS, ND, CND) \
  SND_CMP_OP (mx_el_eq, ==, S,   , ND,    ) \
  SND_CMP_OP (mx_el_ne, !=, S,   , ND,    )

mx-op-defs.h の 630 行で定義されています。

#define SND_OP_DECLS (  R,
S,
ND    ) 
 

値:

SND_BIN_OP_DECLS (R, S, ND) \
  SND_CMP_OP_DECLS (S, ND) \
  SND_BOOL_OP_DECLS (S, ND)

mx-op-defs.h の 668 行で定義されています。

#define SV_BIN_OP (  R,
F,
OP,
S,
V    ) 
 

値:

R \
  F (const S& s, const V& v) \
  { \
    int len = v.length (); \
 \
    R r (len); \
 \
    for (int i = 0; i < len; i++) \
      r.elem(i) = s OP v.elem(i); \
 \
    return r; \
  }

mx-op-defs.h の 85 行で定義されています。

#define SV_BIN_OP_DECLS (  R,
S,
V    ) 
 

値:

BIN_OP_DECL (R, operator +, S, V); \
  BIN_OP_DECL (R, operator -, S, V); \
  BIN_OP_DECL (R, operator *, S, V); \
  BIN_OP_DECL (R, operator /, S, V);

mx-op-defs.h の 79 行で定義されています。

#define SV_BIN_OPS (  R,
S,
V    ) 
 

値:

SV_BIN_OP (R, operator +, +, S, V) \
  SV_BIN_OP (R, operator -, -, S, V) \
  SV_BIN_OP (R, operator *, *, S, V) \
  SV_BIN_OP (R, operator /, /, S, V)

mx-op-defs.h の 99 行で定義されています。

#define SV_OP_DECLS (  R,
S,
V    )     SV_BIN_OP_DECLS(R, S, V)
 

mx-op-defs.h の 105 行で定義されています。

#define VS_BIN_OP (  R,
F,
OP,
V,
S    ) 
 

値:

R \
  F (const V& v, const S& s) \
  { \
    int len = v.length (); \
 \
    R r (len); \
 \
    for (int i = 0; i < len; i++) \
      r.elem(i) = v.elem(i) OP s; \
 \
    return r; \
  }

mx-op-defs.h の 54 行で定義されています。

#define VS_BIN_OP_DECLS (  R,
V,
S    ) 
 

値:

BIN_OP_DECL (R, operator +, V, S); \
  BIN_OP_DECL (R, operator -, V, S); \
  BIN_OP_DECL (R, operator *, V, S); \
  BIN_OP_DECL (R, operator /, V, S);

mx-op-defs.h の 48 行で定義されています。

#define VS_BIN_OPS (  R,
V,
S    ) 
 

値:

VS_BIN_OP (R, operator +, +, V, S) \
  VS_BIN_OP (R, operator -, -, V, S) \
  VS_BIN_OP (R, operator *, *, V, S) \
  VS_BIN_OP (R, operator /, /, V, S)

mx-op-defs.h の 68 行で定義されています。

#define VS_OP_DECLS (  R,
V,
S    )     VS_BIN_OP_DECLS(R, V, S)
 

mx-op-defs.h の 74 行で定義されています。

#define VV_BIN_OP (  R,
F,
OP,
V1,
V2    ) 
 

値:

R \
  F (const V1& v1, const V2& v2) \
  { \
    R r; \
 \
    int v1_len = v1.length (); \
    int v2_len = v2.length (); \
 \
    if (v1_len != v2_len) \
      gripe_nonconformant (#OP, v1_len, v2_len); \
    else \
      { \
        r.resize (v1_len); \
 \
        for (int i = 0; i < v1_len; i++) \
          r.elem(i) = v1.elem(i) OP v2.elem(i); \
      } \
 \
    return r; \
  }

mx-op-defs.h の 116 行で定義されています。

#define VV_BIN_OP_DECLS (  R,
V1,
V2    ) 
 

値:

BIN_OP_DECL (R, operator +, V1, V2); \
  BIN_OP_DECL (R, operator -, V1, V2); \
  BIN_OP_DECL (R, product,    V1, V2); \
  BIN_OP_DECL (R, quotient,   V1, V2);

mx-op-defs.h の 110 行で定義されています。

#define VV_BIN_OPS (  R,
V1,
V2    ) 
 

値:

VV_BIN_OP (R, operator +, +, V1, V2) \
  VV_BIN_OP (R, operator -, -, V1, V2) \
  VV_BIN_OP (R, product,    *, V1, V2) \
  VV_BIN_OP (R, quotient,   /, V1, V2)

mx-op-defs.h の 138 行で定義されています。

#define VV_OP_DECLS (  R,
V1,
V2    )     VV_BIN_OP_DECLS(R, V1, V2)
 

mx-op-defs.h の 144 行で定義されています。

Wed Dec 29 12:41:59 2004に生成されました。 doxygen1.2.18
SEO [PR] 爆速!無料ブログ 無料ホームページ開設 無料ライブ放送