aboutsummaryrefslogtreecommitdiff
path: root/externals/grill/vasp/source/opdefs.h
diff options
context:
space:
mode:
Diffstat (limited to 'externals/grill/vasp/source/opdefs.h')
-rw-r--r--externals/grill/vasp/source/opdefs.h364
1 files changed, 364 insertions, 0 deletions
diff --git a/externals/grill/vasp/source/opdefs.h b/externals/grill/vasp/source/opdefs.h
new file mode 100644
index 00000000..bf9101f7
--- /dev/null
+++ b/externals/grill/vasp/source/opdefs.h
@@ -0,0 +1,364 @@
+/*
+
+VASP modular - vector assembling signal processor / objects for Max/MSP and PD
+
+Copyright (c) 2002 Thomas Grill (xovo@gmx.net)
+For information on usage and redistribution, and for a DISCLAIMER OF ALL
+WARRANTIES, see the file, "license.txt," in this distribution.
+
+*/
+
+#ifndef __VASP_OPDEFS_H
+#define __VASP_OPDEFS_H
+
+#include "oploop.h"
+
+#ifdef VASP_CHN1
+#define _D_ALWAYS1 1
+#else
+#define _D_ALWAYS1 0
+#endif
+
+/*! \brief skeleton for unary real operations
+*/
+#define _D__run(fun,p) \
+{ \
+ register const S *sr = p.rsdt; \
+ register S *dr = p.rddt; \
+ register I i; \
+ if(sr == dr) \
+ if(_D_ALWAYS1 || p.rds == 1) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr); dr++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr); dr += p.rds; } \
+ _E_LOOP \
+ else \
+ if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr); sr++,dr++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr); sr += p.rss,dr += p.rds; } \
+ _E_LOOP \
+ return true; \
+}
+
+#define d__run(fun,p) { return _d__run(fun,p); }
+
+/*! \brief skeleton for unary complex operations
+*/
+#define _D__cun(fun,p) \
+{ \
+ register const S *sr = p.rsdt,*si = p.isdt; \
+ register S *dr = p.rddt,*di = p.iddt; \
+ register I i; \
+ if(sr == dr && si == di) \
+ if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di); dr++,di++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di); dr += p.rds,di += p.ids; } \
+ _E_LOOP \
+ else \
+ if(_D_ALWAYS1 || (p.rss == 1 && p.iss == 1 && p.rds == 1 && p.ids == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*sr,*si); sr++,si++,dr++,di++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*sr,*si); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids; } \
+ _E_LOOP \
+ return true; \
+}
+
+#define d__cun(fun,p) { return _d__cun(fun,p); }
+
+
+/*! \brief skeleton for binary real operations
+*/
+#define _D__rbin(fun,p) \
+{ \
+ register const S *sr = p.rsdt; \
+ register S *dr = p.rddt; \
+ register I i; \
+ if(p.HasArg() && p.arg[0].Is()) { \
+ switch(p.arg[0].argtp) { \
+ case OpParam::Arg::arg_v: { \
+ register const S *ar = p.arg[0].v.rdt; \
+ if(p.rsdt == p.rddt) \
+ if(_D_ALWAYS1 || (p.rds == 1 && p.arg[0].v.rs == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr,*ar); dr++,ar++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr,*ar); dr += p.rds,ar += p.arg[0].v.rs; } \
+ _E_LOOP \
+ else \
+ if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1 && p.arg[0].v.rs == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr,*ar); sr++,dr++,ar++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr,*ar); sr += p.rss,dr += p.rds,ar += p.arg[0].v.rs; } \
+ _E_LOOP \
+ break; \
+ } \
+ case OpParam::Arg::arg_env: { \
+ Env::Iter it(*p.arg[0].e.env); it.Init(0); \
+ if(p.rsdt == p.rddt) \
+ if(_D_ALWAYS1 || p.rds == 1) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr,it.ValFwd(i)); dr++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr,it.ValFwd(i)); dr += p.rds; } \
+ _E_LOOP \
+ else \
+ if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr,it.ValFwd(i)); sr++,dr++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr,it.ValFwd(i)); sr += p.rss,dr += p.rds; } \
+ _E_LOOP \
+ break; \
+ } \
+ case OpParam::Arg::arg_x: { \
+ const R v = p.arg[0].x.r; \
+ if(p.rsdt == p.rddt) \
+ if(_D_ALWAYS1 || p.rds == 1) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr,v); dr++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr,v); dr += p.rds; } \
+ _E_LOOP \
+ else \
+ if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr,v); sr++,dr++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr,v); sr += p.rss,dr += p.rds; } \
+ _E_LOOP \
+ break; \
+ } \
+ } \
+ } \
+ else { \
+ register const S v = p.rbin.arg; \
+ if(p.rsdt == p.rddt) \
+ if(_D_ALWAYS1 || p.rds == 1) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr,v); dr++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr,v); dr += p.rds; } \
+ _E_LOOP \
+ else \
+ if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr,v); sr++,dr++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr,v); sr += p.rss,dr += p.rds; } \
+ _E_LOOP \
+ } \
+ return true; \
+}
+
+#define d__rbin(fun,p) { return _d__rbin(fun,p); }
+
+
+/*! \brief skeleton for binary complex operations
+*/
+#define _D__cbin(fun,p) \
+{ \
+ register const S *sr = p.rsdt,*si = p.isdt; \
+ register S *dr = p.rddt,*di = p.iddt; \
+ register I i; \
+ if(p.HasArg() && p.arg[0].Is()) { \
+ switch(p.arg[0].argtp) { \
+ case OpParam::Arg::arg_v: { \
+ register const S *ar = p.arg[0].v.rdt,*ai = p.arg[0].v.idt; \
+ if(ai) \
+ if(sr == dr && si == di) \
+ if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1 && p.arg[0].v.rs == 1 && p.arg[0].v.is == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di,*ar,*ai); dr++,di++,ar++,ai++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di,*ar,*ai); dr += p.rds,di += p.ids,ar += p.arg[0].v.rs,ai += p.arg[0].v.is; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*sr,*si,*ar,*ai); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids,ar += p.arg[0].v.rs,ai += p.arg[0].v.is; } \
+ _E_LOOP \
+ else \
+ if(sr == dr && si == di) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di,*ar,0); dr += p.rds,di += p.ids,ar += p.arg[0].v.rs; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*sr,*si,*ar,0); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids,ar += p.arg[0].v.rs; } \
+ _E_LOOP \
+ break; \
+ } \
+ case OpParam::Arg::arg_env: { \
+ Env::Iter it(*p.arg[0].e.env); it.Init(0); \
+ if(sr == dr && si == di) \
+ if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di,it.ValFwd(i),0); dr++,di++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di,it.ValFwd(i),0); dr += p.rds,di += p.ids; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*sr,*si,it.ValFwd(i),0); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids; } \
+ _E_LOOP \
+ break; \
+ } \
+ case OpParam::Arg::arg_x: { \
+ register const R ar = p.arg[0].x.r,ai = p.arg[0].x.i; \
+ if(sr == dr && si == di) \
+ if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di,ar,ai); dr++,di++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di,ar,ai); dr += p.rds,di += p.ids; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*sr,*si,ar,ai); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids; } \
+ _E_LOOP \
+ break; \
+ } \
+ } \
+ } \
+ else { \
+ register const S rv = p.cbin.rarg,iv = p.cbin.iarg; \
+ if(sr == dr && si == di) \
+ if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di,rv,iv); dr++,di++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di,rv,iv); dr += p.rds,di += p.ids; } \
+ _E_LOOP \
+ else \
+ if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1 && p.rss == 1 && p.iss == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*sr,*si,rv,iv); sr++,si++,dr++,di++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*sr,*si,rv,iv); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids; } \
+ _E_LOOP \
+ } \
+ return true; \
+}
+
+#define d__cbin(fun,p) { return _d__cbin(fun,p); }
+
+
+/*! \brief skeleton for real operations with parameter block
+*/
+#define _D__rop(fun,p) \
+{ \
+ register const S *sr = p.rsdt; \
+ register S *dr = p.rddt; \
+ register I i; \
+ if(sr == dr) \
+ if(_D_ALWAYS1 || p.rds == 1) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr,p); dr++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*dr,p); dr += p.rds; } \
+ _E_LOOP \
+ else \
+ if(_D_ALWAYS1 || (p.rss == 1 && p.rds == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr,p); sr++,dr++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*sr,p); sr += p.rss,dr += p.rds; } \
+ _E_LOOP \
+ return true; \
+}
+
+#define d__rop(fun,p) { return _d__rop(fun,p); }
+
+
+/*! \brief skeleton for complex operations with parameter block
+*/
+#define _D__cop(fun,p) \
+{ \
+ register const S *sr = p.rsdt,*si = p.isdt; \
+ register S *dr = p.rddt,*di = p.iddt; \
+ register I i; \
+ if(sr == dr && si == di) \
+ if(_D_ALWAYS1 || (p.rds == 1 && p.ids == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di,p); dr++,di++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*dr,*di,p); dr += p.rds,di += p.ids; } \
+ _E_LOOP \
+ else \
+ if(_D_ALWAYS1 || (p.rss == 1 && p.iss == 1 && p.rds == 1 && p.ids == 1)) \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*sr,*si,p); sr++,si++,dr++,di++; } \
+ _E_LOOP \
+ else \
+ _D_LOOP(i,p.frames) \
+ { fun(*dr,*di,*sr,*si,p); sr += p.rss,si += p.iss,dr += p.rds,di += p.ids; } \
+ _E_LOOP \
+ return true; \
+}
+
+#define d__cop(fun,p) { return _d__cop(fun,p); }
+
+
+#ifdef VASP_COMPACT
+#define D__run(fun,p) d__run(fun,p)
+#define D__cun(fun,p) d__cun(fun,p)
+#define D__rbin(fun,p) d__rbin(fun,p)
+#define D__cbin(fun,p) d__cbin(fun,p)
+#define D__rop(fun,p) d__rop(fun,p)
+#define D__cop(fun,p) d__cop(fun,p)
+#else
+#define D__run(fun,p) _D__run(fun,p)
+#define D__cun(fun,p) _D__cun(fun,p)
+#define D__rbin(fun,p) _D__rbin(fun,p)
+#define D__cbin(fun,p) _D__cbin(fun,p)
+#define D__rop(fun,p) _D__rop(fun,p)
+#define D__cop(fun,p) _D__cop(fun,p)
+#endif
+
+#endif
generated by cgit v1.2.1 (git 2.18.0) at 2024-07-03 15:54:06 +0000