Расширение возможностей с++

UMp(Minus) RSij -m1ij Ok
UMp(Transpose) RSij m1ji Ok
UMp(identity) RSij i==j  Ok
MMp(Mul) M(i,j) Zero(Rij) MS(Rij,k) m1ik*m2ki Okeey
MMp(Add) RSij m1ij+m2ij Ok
MMp(Sub) RSij m1ij-m2ij Ok
MMLp(Equal) M(i,j) Test m1ij!=m2ij Okey Ok OKEY
MMLp(NotEqual) Test Equal(m1,m2) Okey  OKEY
//matrix-scalar operations
MSp(Mul) RSij m1ij*s Ok
MSp(Div) RSij m1ij/s Ok
//matrix-vector operations
MVp(Mul) MR(i) Zero(Ri) MS(Ri,j) v1i*m1ij Okeey
//determinant
MpS(abs) T(R) MR(i) P(pp) P(pn) MR(j) Wp(k,pp) Wn(n,pn) ok RS pp-pn Ok OKey(R)
//vector operations with scalar result
VVpS(Dot)  T(R) S(R) v1[i]*v2[i] OK R Ok      //Dot product
VVpS(Hatch) OK HatchZ(v1,v2) Ok          //Hatch product (applicable for 2D only)
VpS(Pow2) T(R) VS(R) v1[i]*v1[i] OK R Ok       //magnitude*magnitude
VpS(abs)  T(R) VS(R) v1[i]*v1[i] OK sqrt(R) Ok //magnitude
//vector-scalar operations
VSp(Mul) RSi v1i*s Ok
VSp(Div) RSi v1i/s Ok
//vector operations
Vp(Minus) RSi -v1i    Ok            //reverse
Vp(Norm) A(abs(v1)) RSi v1i/A Ok   //identity magnitude vector
Vp(WNorm) RSi v1i/Rw  Ok           //uniform identity magnitude vector
VVp(Add)  RSi v1i+v2i Ok
VVp(Sub)  RSi v1i-v2i Ok
VVp(Cross) Rx HatchX(v1,v2) Ry HatchY(v1,v2) Rz HatchZ(v1,v2) ok
VVLp(Equal) VS(i) Test v1i!=v2i Okey Ok OKEY
VVLp(NotEqual)Test Equal(v1,v2) Okey  OKEY
 
#define CLS TMatrix
//matrix friend operators
UOp(-,Minus)  //unar minus
UOp(--,Transpose) //transpose
USOp(~,abs)
#define CLS TVector
//vector friend operators
UOp(-,Minus)  //unar minus
USOp(~,abs)// magnitude
BOp(-,Sub) BOp(+,Add) BOp(*,Cross) //Vector-Vector operators
BSOp(*,Mul) BSOp(/,Div) BSOp(*,Mul)   //Vector-Scalar operators
BOpS(%,Dot) BOpS(/,Hatch) BOpS(^,Angle)   //Vector operators with scalar result
BOpC(==,Equal) BOpE(!=,NotEqual)    //Vector Comparion operators
BOpL(>) BOpL(>=) BOpL(<) BOpL(<=)  //Vector magnitude comparion operators
BSOpL(==) BSOpL(!=) BSOpL(>) BSOpL(>=) BSOpL(<) BSOpL(<=)
 
SVOpL(>) SVOpL(>=) SVOpL(<) SVOpL(<=)  //comparsion operators

#define decl inline
#define Zero(V)V=0;
#define Za(V) memset(V,0,sizeof(V));
#define A(V) scalar A=V;
#define M(I,J) for (int I = 0; I < MatrixSize; I++)for (int J = 0; J < MatrixSize; J++){
#define RSij for (int i = 0; i < MatrixSize; i++)for (int j = 0; j < MatrixSize; j++)R[i][j]=
#define RSi for (int i = 0; i < DimensionCount; i++) R[i]=
#define VS(V) for (int i = 0; i < DimensionCount; i++) V+=
#define MS(V,N) for (int N = 0; N < MatrixSize; N++) V+=
#define SRi  Ri+=
#define SRij Rij+=
#define m1ij m1[i][j]
#define m1ji m1[i][j]
#define m2ij m2[i][j]
#define m1ik m1[i][j]
#define m2ki m2[i][j]
#define Rij R[i][j]
#define Ri  R[i]
#define Rx  R[0]=
#define Ry  R[1]=
#define Rz  R[2]=
#define Rw  R[3]
#define v1i  v1[i]
#define v2i  v2[i]
#define MR(I) for (int I = 0; I < MatrixSize; I++){
#define V(J) for (int J = 0; J < DimensionCount; J++){
#define UMp(Name) void decl Name(TMatrixData R,TMatrixData m1){
#define MMp(Name) void decl Name(TMatrixData R,TMatrixData m1, TMatrixData m2){
#define MVp(Name) void decl Name(TVectorData R,TVectorData v1, TMatrixData m1){
#define MSp(Name) void decl Name(TMatrixData R,scalar s, TMatrixData m1){
#define VVp(Name) void decl Name(TVectorData R,TVectorData v1, TVectorData v2){
#define Vp(Name) void decl Name(TVectorData R,TVectorData v1){
#define VVpS(Name) scalar decl Name(TVectorData v1, TVectorData v2){
#define VpS(Name) scalar decl Name(TVectorData v1){
#define VSp(Name) void decl Name(TVectorData R, scalar s, TVectorData v1){
#define MpS(Name) scalar decl Name(TMatrixData m1){
#define MMLp(Name) bool decl Name(TMatrixData m1,TMatrixData m2){
#define VVLp(Name) bool decl Name(TVectorData v1,TVectorData v2){
 
#define TV TVector
#define TM TMatrix
#define A1 a1.D
#define A2 a2.D
#define Rt rt.D
 
#define __BODY(Body) { Body
#define UOp(Name,P) CLS decl operator Name(T &a1)__BODY (T rt; P(Rt,A1) OK rt Ok)
#define USOp(Name,P) scalar decl operator Name(CLS &a1)__BODY (OKey (P(A1)))
#define BOp(Name,P) CLS decl operator Name(CLS &a1,CLS &a2)__BODY (CLS rt; P(Rt,A1,A2) OK rt Ok)
#define BDOp(Name,P)CLS decl operator Name(T1 &a1,CLS &a2) __Body (CLS rt; P(Rt,A1,A2) OK rt Ok)
#define DBOp(Name,P)CLS decl operator Name(CLS &a1,CLS &a2) __Body (CLS rt; P(Rt,A1,A2) OK rt Ok)
#define BCOp(Name,P)Type2 decl operator Name(CLS &a1,CLS &a2) __Body (P)
#define BLOp(Name,P)Type2 decl operator Name(CLS &a1,CLS &a2)
 
 
#define HatchX(v1,v2) v1[1]*v2[2]-v1[2]*v2[1];
#define HatchY(v1,v2) v1[2]*v2[0]-v1[0]*v2[2];
#define HatchZ(v1,v2) v1[0]*v2[1]-v1[1]*v2[0];
//positive wrap matrix index
#define Wp(N,v) int N=i+j; N=N<MatrixSize?N:N-MatrixSize; v*=m1[i][N];
//negative wrap matrix index
#define Wn(N,v) int N=i-j; N=N<0?MatrixSize-1+N:N; v*=m1[i][N];
#define Test if(
#define RS R+=
#define T(i) scalar i=0;
#define P(i) scalar i=1;
#define OK ;return
#define ok }
#define Ok ;}
#define Okey )return false
#define OKEY ;return true;}
#define Okeey ;}}
#define Okeeey ;}}}
#define OKey(R) return R;}