1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
/*
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_OPPARAM_H
#define __VASP_OPPARAM_H
#include "vecblk.h"
#include "arg.h"
class OpParam {
public:
OpParam(const C *opnm,I args);
~OpParam();
V InitArgs(I nargs);
V Clear();
BL HasArg() const { return arg != NULL; }
const C *opName() const { return opname; }
// check for overlap
// \remark if on same vector, stride is the same for src, arg, dst!
inline BL SR_In() const { return rddt > rsdt && rddt < rsdt+frames*rss; }
inline BL SI_In() const { return iddt > isdt && iddt < isdt+frames*iss; }
BL AR_In(I bl) const;
BL AI_In(I bl) const;
BL AR_In() const;
BL AI_In() const;
// Can we reverse direction?
inline BL SR_Can() const { return rsdt <= rddt || rsdt >= rddt+frames*rds; }
inline BL SI_Can() const { return isdt <= iddt || isdt >= iddt+frames*ids; }
BL AR_Can(I bl) const;
BL AI_Can(I bl) const;
BL AR_Can() const;
BL AI_Can() const;
// does it overlap? (works only with rss,rds,ras.... > 0)
inline BL SR_Ovr() const { return rddt != rsdt && rddt < rsdt+frames*rss && rsdt < rddt+frames*rds; }
inline BL SI_Ovr() const { return iddt != isdt && iddt < isdt+frames*iss && isdt < iddt+frames*ids; }
BL AR_Ovr(I bl) const;
BL AI_Ovr(I bl) const;
BL AR_Ovr() const;
BL AI_Ovr() const;
V AR_Rev();
V AI_Rev();
V R_Rev();
V C_Rev();
V SkipOddMiddle();
V SkipOddMiddle(S m);
const C *opname;
I frames,symm,args;
BL ovrlap,revdir,oddrem;
S *rsdt,*isdt; I rss,iss;
S *rddt,*iddt; I rds,ids;
class Arg
{
public:
Arg(): argtp(arg_) {}
// Arg(const Arg &op) { operator =(op); }
~Arg() { Clear(); }
V Clear();
BL Is() const { return argtp != arg_; }
// Arg &operator =(const Arg &op);
// Arg &operator =(const Argument &arg);
Arg &SetX(S r,S i = 0);
Arg &SetV(S *r,I rs,S *i = NULL,I is = 0);
Arg &SetE(const Env *bp);
typedef struct env_t { const Env *env; };
typedef struct v_t { S *rdt,*idt; I rs,is; };
typedef struct x_t { R r,i; };
enum { arg_ = 0,arg_x,arg_v,arg_env } argtp;
union {
x_t x;
v_t v;
env_t e;
};
};
Arg *arg;
union {
struct { R coef,carry; I rep; } flt;
struct { R carry; I rep; } intdif;
struct { BL cx; R density; I cnt; } peaks;
struct { R ph,phinc; } gen;
struct { R factor,center; I mode,fill; } tilt;
struct { R cur,inc; } bvl;
struct { R sh; I ish; I fill; } sh;
struct { I wndtp; BL inv,mul; R p1,p2,p3; } wnd;
struct { R minmax,scl; } norm;
struct { I arg; } ibin;
struct { R arg; } rbin;
struct { R rarg,iarg; } cbin;
struct { I *order; } perm;
struct { R val; I offs,dif,dir,slope; } srch;
};
private:
// reverse direction
inline V SR_Rev() { rsdt -= (frames-1)*(rss = -rss); }
inline V SI_Rev() { isdt -= (frames-1)*(iss = -iss); }
V AR_Rev(I bl);
V AI_Rev(I bl);
inline V DR_Rev() { rddt -= (frames-1)*(rds = -rds); }
inline V DI_Rev() { iddt -= (frames-1)*(ids = -ids); }
};
#endif
|
