My Project
Loading...
Searching...
No Matches
Macros
p_MemAdd.h File Reference

Go to the source code of this file.

Macros

#define _p_MemSum(i, r, s1, s2)   r[i] = s1[i] + s2[i]
 
#define _p_MemSum_LengthOne(r, s1, s2)   _p_MemSum(0, r, s1, s2)
 
#define _p_MemSum_LengthTwo(r, s1, s2)   do{_p_MemSum_LengthOne(r, s1, s2); _p_MemSum(1, r, s1, s2);} while(0)
 
#define _p_MemSum_LengthThree(r, s1, s2)   do{_p_MemSum_LengthTwo(r, s1, s2); _p_MemSum(2, r, s1, s2);} while(0)
 
#define _p_MemSum_LengthFour(r, s1, s2)   do{_p_MemSum_LengthThree(r, s1, s2); _p_MemSum(3, r, s1, s2);} while(0)
 
#define _p_MemSum_LengthFive(r, s1, s2)   do{_p_MemSum_LengthFour(r, s1, s2); _p_MemSum(4, r, s1, s2);} while(0)
 
#define _p_MemSum_LengthSix(r, s1, s2)   do{_p_MemSum_LengthFive(r, s1, s2); _p_MemSum(5, r, s1, s2);} while(0)
 
#define _p_MemSum_LengthSeven(r, s1, s2)   do{_p_MemSum_LengthSix(r, s1, s2); _p_MemSum(6, r, s1, s2);} while(0)
 
#define _p_MemSum_LengthEight(r, s1, s2)   do{_p_MemSum_LengthSeven(r, s1, s2); _p_MemSum(7, r, s1, s2);} while(0)
 
#define _p_MemSum_Declare(r, s1, s2)
 
#define p_MemSum_LengthOne(r, s1, s2, length)   _p_MemSum_LengthOne(r, s1, s2)
 
#define p_MemSum_LengthTwo(r, s1, s2, length)
 
#define p_MemSum_LengthThree(r, s1, s2, length)
 
#define p_MemSum_LengthFour(r, s1, s2, length)
 
#define p_MemSum_LengthFive(r, s1, s2, length)
 
#define p_MemSum_LengthSix(r, s1, s2, length)
 
#define p_MemSum_LengthSeven(r, s1, s2, length)
 
#define p_MemSum_LengthEight(r, s1, s2, length)
 
#define p_MemSum_LengthGeneral(r, s1, s2, length)
 
#define _p_MemAdd(i, r, s)   r[i] += s[i]
 
#define _p_MemAdd_LengthOne(r, s)   _p_MemAdd(0, r, s)
 
#define _p_MemAdd_LengthTwo(r, s)   do{_p_MemAdd_LengthOne(r, s); _p_MemAdd(1, r, s);} while(0)
 
#define _p_MemAdd_LengthThree(r, s)   do{_p_MemAdd_LengthTwo(r, s); _p_MemAdd(2, r, s);} while(0)
 
#define _p_MemAdd_LengthFour(r, s)   do{_p_MemAdd_LengthThree(r, s); _p_MemAdd(3, r, s);} while(0)
 
#define _p_MemAdd_LengthFive(r, s)   do{_p_MemAdd_LengthFour(r, s); _p_MemAdd(4, r, s);} while(0)
 
#define _p_MemAdd_LengthSix(r, s)   do{_p_MemAdd_LengthFive(r, s); _p_MemAdd(5, r, s);} while(0)
 
#define _p_MemAdd_LengthSeven(r, s)   do{_p_MemAdd_LengthSix(r, s); _p_MemAdd(6, r, s);} while(0)
 
#define _p_MemAdd_LengthEight(r, s)   do{_p_MemAdd_LengthSeven(r, s); _p_MemAdd(7, r, s);} while(0)
 
#define _p_MemAdd_Declare(r, s)
 
#define p_MemAdd_LengthOne(r, s, length)   _p_MemAdd_LengthOne(r, s)
 
#define p_MemAdd_LengthTwo(r, s, length)
 
#define p_MemAdd_LengthThree(r, s, length)
 
#define p_MemAdd_LengthFour(r, s, length)
 
#define p_MemAdd_LengthFive(r, s, length)
 
#define p_MemAdd_LengthSix(r, s, length)
 
#define p_MemAdd_LengthSeven(r, s, length)
 
#define p_MemAdd_LengthEight(r, s, length)
 
#define p_MemAdd_LengthGeneral(r, s, length)
 
#define _p_MemDiff(i, r, s1, s2)   r[i] = s1[i] - s2[i]
 
#define _p_MemDiff_LengthOne(r, s1, s2)   _p_MemDiff(0, r, s1, s2)
 
#define _p_MemDiff_LengthTwo(r, s1, s2)   do{_p_MemDiff_LengthOne(r, s1, s2); _p_MemDiff(1, r, s1, s2);} while(0)
 
#define _p_MemDiff_LengthThree(r, s1, s2)   do{_p_MemDiff_LengthTwo(r, s1, s2); _p_MemDiff(2, r, s1, s2);} while(0)
 
#define _p_MemDiff_LengthFour(r, s1, s2)   do{_p_MemDiff_LengthThree(r, s1, s2); _p_MemDiff(3, r, s1, s2);} while(0)
 
#define _p_MemDiff_LengthFive(r, s1, s2)   do{_p_MemDiff_LengthFour(r, s1, s2); _p_MemDiff(4, r, s1, s2);} while(0)
 
#define _p_MemDiff_LengthSix(r, s1, s2)   do{_p_MemDiff_LengthFive(r, s1, s2); _p_MemDiff(5, r, s1, s2);} while(0)
 
#define _p_MemDiff_LengthSeven(r, s1, s2)   do{_p_MemDiff_LengthSix(r, s1, s2); _p_MemDiff(6, r, s1, s2);} while(0)
 
#define _p_MemDiff_LengthEight(r, s1, s2)   do{_p_MemDiff_LengthSeven(r, s1, s2); _p_MemDiff(7, r, s1, s2);} while(0)
 
#define _p_MemDiff_Declare(r, s1, s2)
 
#define p_MemDiff_LengthOne(r, s1, s2, length)   _p_MemDiff_LengthOne(r, s1, s2)
 
#define p_MemDiff_LengthTwo(r, s1, s2, length)
 
#define p_MemDiff_LengthThree(r, s1, s2, length)
 
#define p_MemDiff_LengthFour(r, s1, s2, length)
 
#define p_MemDiff_LengthFive(r, s1, s2, length)
 
#define p_MemDiff_LengthSix(r, s1, s2, length)
 
#define p_MemDiff_LengthSeven(r, s1, s2, length)
 
#define p_MemDiff_LengthEight(r, s1, s2, length)
 
#define p_MemDiff_LengthGeneral(r, s1, s2, length)
 
#define _p_MemSub(i, r, s)   r[i] -= s[i]
 
#define _p_MemSub_Declare(r, s)
 
#define p_MemSub_LengthGeneral(r, s, length)
 
#define _p_MemAddSub_Declare(r, s, t)
 
#define p_MemAddSub_LengthGeneral(r, s, t, length)
 

Macro Definition Documentation

◆ _p_MemAdd

#define _p_MemAdd (   i,
  r,
  s 
)    r[i] += s[i]

Definition at line 107 of file p_MemAdd.h.

◆ _p_MemAdd_Declare

#define _p_MemAdd_Declare (   r,
  s 
)
Value:
const unsigned long* _s = ((unsigned long*) s); \
unsigned long* _r = ((unsigned long*) r)
const CanonicalForm int s
Definition facAbsFact.cc:51

Definition at line 118 of file p_MemAdd.h.

124{ \
127} \
128while (0)
129#define p_MemAdd_LengthThree(r, s, length) \
130do \
131{ \
132 _p_MemAdd_Declare(r,s); \
133 _p_MemAdd_LengthThree(_r, _s); \
134} \
135while (0)
136#define p_MemAdd_LengthFour(r, s, length) \
137do \
138{ \
139 _p_MemAdd_Declare(r,s); \
140 _p_MemAdd_LengthFour(_r, _s); \
141} \
142while (0)
143#define p_MemAdd_LengthFive(r, s, length) \
144do \
145{ \
146 _p_MemAdd_Declare(r,s); \
147 _p_MemAdd_LengthFive(_r, _s); \
148} \
149while (0)
150#define p_MemAdd_LengthSix(r, s, length) \
151do \
152{ \
153 _p_MemAdd_Declare(r,s); \
154 _p_MemAdd_LengthSix(_r, _s); \
155} \
156while (0)
157#define p_MemAdd_LengthSeven(r, s, length) \
158do \
159{ \
160 _p_MemAdd_Declare(r,s); \
161 _p_MemAdd_LengthSeven(_r, _s); \
162} \
163while (0)
164#define p_MemAdd_LengthEight(r, s, length) \
165do \
166{ \
167 _p_MemAdd_Declare(r,s); \
168 _p_MemAdd_LengthEight(_r, _s); \
169} \
170while (0)
171
172#define p_MemAdd_LengthGeneral(r, s, length) \
173do \
174{ \
175 _p_MemAdd_Declare(r,s); \
176 const unsigned long _l = (unsigned long) length; \
177 unsigned long _i = 0; \
178 \
179 do \
180 { \
181 _r[_i] += _s[_i]; \
182 _i++; \
183 } \
184 while (_i != _l); \
185} \
186while (0)
187
188
189/***************************************************************
190 *
191 * MemDiff
192 *
193 ***************************************************************/
194#define _p_MemDiff(i, r, s1, s2) r[i] = s1[i] - s2[i]
195
196#define _p_MemDiff_LengthOne(r, s1, s2) _p_MemDiff(0, r, s1, s2)
197#define _p_MemDiff_LengthTwo(r, s1, s2) do{_p_MemDiff_LengthOne(r, s1, s2); _p_MemDiff(1, r, s1, s2);} while(0)
198#define _p_MemDiff_LengthThree(r, s1, s2) do{_p_MemDiff_LengthTwo(r, s1, s2); _p_MemDiff(2, r, s1, s2);} while(0)
199#define _p_MemDiff_LengthFour(r, s1, s2) do{_p_MemDiff_LengthThree(r, s1, s2); _p_MemDiff(3, r, s1, s2);} while(0)
200#define _p_MemDiff_LengthFive(r, s1, s2) do{_p_MemDiff_LengthFour(r, s1, s2); _p_MemDiff(4, r, s1, s2);} while(0)
201#define _p_MemDiff_LengthSix(r, s1, s2) do{_p_MemDiff_LengthFive(r, s1, s2); _p_MemDiff(5, r, s1, s2);} while(0)
202#define _p_MemDiff_LengthSeven(r, s1, s2) do{_p_MemDiff_LengthSix(r, s1, s2); _p_MemDiff(6, r, s1, s2);} while(0)
203#define _p_MemDiff_LengthEight(r, s1, s2) do{_p_MemDiff_LengthSeven(r, s1, s2); _p_MemDiff(7, r, s1, s2);} while(0)
204
205#define _p_MemDiff_Declare(r, s1, s2) \
206 const unsigned long* _s1 = ((unsigned long*) s1); \
207 const unsigned long* _s2 = ((unsigned long*) s2); \
208 unsigned long* _r = ((unsigned long*) r)
209
210#define p_MemDiff_LengthOne(r, s1, s2, length) _p_MemDiff_LengthOne(r, s1, s2)
211#define p_MemDiff_LengthTwo(r, s1, s2, length) \
212do \
213{ \
214 _p_MemDiff_Declare(r,s1,s2); \
215 _p_MemDiff_LengthTwo(_r, _s1, _s2); \
216} \
217while (0)
218#define p_MemDiff_LengthThree(r, s1, s2, length) \
219do \
220{ \
221 _p_MemDiff_Declare(r,s1,s2); \
222 _p_MemDiff_LengthThree(_r, _s1, _s2); \
223} \
224while (0)
225#define p_MemDiff_LengthFour(r, s1, s2, length) \
226do \
227{ \
228 _p_MemDiff_Declare(r,s1,s2); \
229 _p_MemDiff_LengthFour(_r, _s1, _s2); \
230} \
231while (0)
232#define p_MemDiff_LengthFive(r, s1, s2, length) \
233do \
234{ \
235 _p_MemDiff_Declare(r,s1,s2); \
236 _p_MemDiff_LengthFive(_r, _s1, _s2); \
237} \
238while (0)
239#define p_MemDiff_LengthSix(r, s1, s2, length) \
240do \
241{ \
242 _p_MemDiff_Declare(r,s1,s2); \
243 _p_MemDiff_LengthSix(_r, _s1, _s2); \
244} \
245while (0)
246#define p_MemDiff_LengthSeven(r, s1, s2, length) \
247do \
248{ \
249 _p_MemDiff_Declare(r,s1,s2); \
250 _p_MemDiff_LengthSeven(_r, _s1, _s2); \
251} \
252while (0)
253#define p_MemDiff_LengthEight(r, s1, s2, length) \
254do \
255{ \
256 _p_MemDiff_Declare(r,s1,s2); \
257 _p_MemDiff_LengthEight(_r, _s1, _s2); \
258} \
259while (0)
260
261#define p_MemDiff_LengthGeneral(r, s1, s2, length) \
262do \
263{ \
264 _p_MemDiff_Declare(r,s1,s2); \
265 const unsigned long _l = (unsigned long) length; \
266 unsigned long _i = 0; \
267 \
268 do \
269 { \
270 _r[_i] = _s1[_i] - _s2[_i]; \
271 _i++; \
272 } \
273 while (_i != _l); \
274} \
275while (0)
276
277
278/***************************************************************
279 *
280 * MemSub
281 *
282 ***************************************************************/
283
284#define _p_MemSub(i, r, s) r[i] -= s[i]
285
286#define _p_MemSub_Declare(r, s) \
287 const unsigned long* _s = ((unsigned long*) s); \
288 unsigned long* _r = ((unsigned long*) r)
289
290#define p_MemSub_LengthGeneral(r, s, length) \
291do \
292{ \
293 _p_MemSub_Declare(r,s); \
294 const unsigned long _l = (unsigned long) length; \
295 unsigned long _i = 0; \
296 \
297 do \
298 { \
299 _r[_i] -= _s[_i]; \
300 _i++; \
301 } \
302 while (_i != _l); \
303} \
304while (0)
305
306#define _p_MemAddSub_Declare(r, s, t) \
307 const unsigned long* _s = ((unsigned long*) s); \
308 const unsigned long* _t = ((unsigned long*) t); \
309 unsigned long* _r = ((unsigned long*) r)
310
311#define p_MemAddSub_LengthGeneral(r, s, t, length) \
312do \
313{ \
314 _p_MemAddSub_Declare(r,s, t); \
315 const unsigned long _l = (unsigned long) length; \
316 unsigned long _i = 0; \
317 \
318 do \
319 { \
320 _r[_i] += _s[_i] - _t[_i]; \
321 _i++; \
322 } \
323 while (_i != _l); \
324} \
325while (0)
326
327#endif /* P_MEM_ADD_H */

◆ _p_MemAdd_LengthEight

#define _p_MemAdd_LengthEight (   r,
  s 
)    do{_p_MemAdd_LengthSeven(r, s); _p_MemAdd(7, r, s);} while(0)

Definition at line 116 of file p_MemAdd.h.

◆ _p_MemAdd_LengthFive

#define _p_MemAdd_LengthFive (   r,
  s 
)    do{_p_MemAdd_LengthFour(r, s); _p_MemAdd(4, r, s);} while(0)

Definition at line 113 of file p_MemAdd.h.

◆ _p_MemAdd_LengthFour

#define _p_MemAdd_LengthFour (   r,
  s 
)    do{_p_MemAdd_LengthThree(r, s); _p_MemAdd(3, r, s);} while(0)

Definition at line 112 of file p_MemAdd.h.

◆ _p_MemAdd_LengthOne

#define _p_MemAdd_LengthOne (   r,
  s 
)    _p_MemAdd(0, r, s)

Definition at line 109 of file p_MemAdd.h.

◆ _p_MemAdd_LengthSeven

#define _p_MemAdd_LengthSeven (   r,
  s 
)    do{_p_MemAdd_LengthSix(r, s); _p_MemAdd(6, r, s);} while(0)

Definition at line 115 of file p_MemAdd.h.

◆ _p_MemAdd_LengthSix

#define _p_MemAdd_LengthSix (   r,
  s 
)    do{_p_MemAdd_LengthFive(r, s); _p_MemAdd(5, r, s);} while(0)

Definition at line 114 of file p_MemAdd.h.

◆ _p_MemAdd_LengthThree

#define _p_MemAdd_LengthThree (   r,
  s 
)    do{_p_MemAdd_LengthTwo(r, s); _p_MemAdd(2, r, s);} while(0)

Definition at line 111 of file p_MemAdd.h.

◆ _p_MemAdd_LengthTwo

#define _p_MemAdd_LengthTwo (   r,
  s 
)    do{_p_MemAdd_LengthOne(r, s); _p_MemAdd(1, r, s);} while(0)

Definition at line 110 of file p_MemAdd.h.

◆ _p_MemAddSub_Declare

#define _p_MemAddSub_Declare (   r,
  s,
 
)
Value:
const unsigned long* _s = ((unsigned long*) s); \
const unsigned long* _t = ((unsigned long*) t); \
unsigned long* _r = ((unsigned long*) r)

Definition at line 307 of file p_MemAdd.h.

◆ _p_MemDiff

#define _p_MemDiff (   i,
  r,
  s1,
  s2 
)    r[i] = s1[i] - s2[i]

Definition at line 195 of file p_MemAdd.h.

◆ _p_MemDiff_Declare

#define _p_MemDiff_Declare (   r,
  s1,
  s2 
)
Value:
const unsigned long* _s1 = ((unsigned long*) s1); \
const unsigned long* _s2 = ((unsigned long*) s2); \
unsigned long* _r = ((unsigned long*) r)

Definition at line 206 of file p_MemAdd.h.

◆ _p_MemDiff_LengthEight

#define _p_MemDiff_LengthEight (   r,
  s1,
  s2 
)    do{_p_MemDiff_LengthSeven(r, s1, s2); _p_MemDiff(7, r, s1, s2);} while(0)

Definition at line 204 of file p_MemAdd.h.

◆ _p_MemDiff_LengthFive

#define _p_MemDiff_LengthFive (   r,
  s1,
  s2 
)    do{_p_MemDiff_LengthFour(r, s1, s2); _p_MemDiff(4, r, s1, s2);} while(0)

Definition at line 201 of file p_MemAdd.h.

◆ _p_MemDiff_LengthFour

#define _p_MemDiff_LengthFour (   r,
  s1,
  s2 
)    do{_p_MemDiff_LengthThree(r, s1, s2); _p_MemDiff(3, r, s1, s2);} while(0)

Definition at line 200 of file p_MemAdd.h.

◆ _p_MemDiff_LengthOne

#define _p_MemDiff_LengthOne (   r,
  s1,
  s2 
)    _p_MemDiff(0, r, s1, s2)

Definition at line 197 of file p_MemAdd.h.

◆ _p_MemDiff_LengthSeven

#define _p_MemDiff_LengthSeven (   r,
  s1,
  s2 
)    do{_p_MemDiff_LengthSix(r, s1, s2); _p_MemDiff(6, r, s1, s2);} while(0)

Definition at line 203 of file p_MemAdd.h.

◆ _p_MemDiff_LengthSix

#define _p_MemDiff_LengthSix (   r,
  s1,
  s2 
)    do{_p_MemDiff_LengthFive(r, s1, s2); _p_MemDiff(5, r, s1, s2);} while(0)

Definition at line 202 of file p_MemAdd.h.

◆ _p_MemDiff_LengthThree

#define _p_MemDiff_LengthThree (   r,
  s1,
  s2 
)    do{_p_MemDiff_LengthTwo(r, s1, s2); _p_MemDiff(2, r, s1, s2);} while(0)

Definition at line 199 of file p_MemAdd.h.

◆ _p_MemDiff_LengthTwo

#define _p_MemDiff_LengthTwo (   r,
  s1,
  s2 
)    do{_p_MemDiff_LengthOne(r, s1, s2); _p_MemDiff(1, r, s1, s2);} while(0)

Definition at line 198 of file p_MemAdd.h.

◆ _p_MemSub

#define _p_MemSub (   i,
  r,
  s 
)    r[i] -= s[i]

Definition at line 285 of file p_MemAdd.h.

◆ _p_MemSub_Declare

#define _p_MemSub_Declare (   r,
  s 
)
Value:
const unsigned long* _s = ((unsigned long*) s); \
unsigned long* _r = ((unsigned long*) r)

Definition at line 287 of file p_MemAdd.h.

◆ _p_MemSum

#define _p_MemSum (   i,
  r,
  s1,
  s2 
)    r[i] = s1[i] + s2[i]

Definition at line 19 of file p_MemAdd.h.

◆ _p_MemSum_Declare

#define _p_MemSum_Declare (   r,
  s1,
  s2 
)
Value:
const unsigned long* _s1 = ((unsigned long*) s1); \
const unsigned long* _s2 = ((unsigned long*) s2); \
unsigned long* _r = ((unsigned long*) r)

Definition at line 30 of file p_MemAdd.h.

◆ _p_MemSum_LengthEight

#define _p_MemSum_LengthEight (   r,
  s1,
  s2 
)    do{_p_MemSum_LengthSeven(r, s1, s2); _p_MemSum(7, r, s1, s2);} while(0)

Definition at line 28 of file p_MemAdd.h.

◆ _p_MemSum_LengthFive

#define _p_MemSum_LengthFive (   r,
  s1,
  s2 
)    do{_p_MemSum_LengthFour(r, s1, s2); _p_MemSum(4, r, s1, s2);} while(0)

Definition at line 25 of file p_MemAdd.h.

◆ _p_MemSum_LengthFour

#define _p_MemSum_LengthFour (   r,
  s1,
  s2 
)    do{_p_MemSum_LengthThree(r, s1, s2); _p_MemSum(3, r, s1, s2);} while(0)

Definition at line 24 of file p_MemAdd.h.

◆ _p_MemSum_LengthOne

#define _p_MemSum_LengthOne (   r,
  s1,
  s2 
)    _p_MemSum(0, r, s1, s2)

Definition at line 21 of file p_MemAdd.h.

◆ _p_MemSum_LengthSeven

#define _p_MemSum_LengthSeven (   r,
  s1,
  s2 
)    do{_p_MemSum_LengthSix(r, s1, s2); _p_MemSum(6, r, s1, s2);} while(0)

Definition at line 27 of file p_MemAdd.h.

◆ _p_MemSum_LengthSix

#define _p_MemSum_LengthSix (   r,
  s1,
  s2 
)    do{_p_MemSum_LengthFive(r, s1, s2); _p_MemSum(5, r, s1, s2);} while(0)

Definition at line 26 of file p_MemAdd.h.

◆ _p_MemSum_LengthThree

#define _p_MemSum_LengthThree (   r,
  s1,
  s2 
)    do{_p_MemSum_LengthTwo(r, s1, s2); _p_MemSum(2, r, s1, s2);} while(0)

Definition at line 23 of file p_MemAdd.h.

◆ _p_MemSum_LengthTwo

#define _p_MemSum_LengthTwo (   r,
  s1,
  s2 
)    do{_p_MemSum_LengthOne(r, s1, s2); _p_MemSum(1, r, s1, s2);} while(0)

Definition at line 22 of file p_MemAdd.h.

◆ p_MemAdd_LengthEight

#define p_MemAdd_LengthEight (   r,
  s,
  length 
)
Value:

Definition at line 165 of file p_MemAdd.h.

167{ \
170} \
171while (0)

◆ p_MemAdd_LengthFive

#define p_MemAdd_LengthFive (   r,
  s,
  length 
)
Value:

Definition at line 144 of file p_MemAdd.h.

146{ \
149} \
150while (0)

◆ p_MemAdd_LengthFour

#define p_MemAdd_LengthFour (   r,
  s,
  length 
)
Value:

Definition at line 137 of file p_MemAdd.h.

139{ \
142} \
143while (0)

◆ p_MemAdd_LengthGeneral

#define p_MemAdd_LengthGeneral (   r,
  s,
  length 
)
Value:
do \
{ \
const unsigned long _l = (unsigned long) length; \
unsigned long _i = 0; \
\
do \
{ \
_r[_i] += _s[_i]; \
_i++; \
} \
while (_i != _l); \
} \
while (0)
static BOOLEAN length(leftv result, leftv arg)
Definition interval.cc:257

Definition at line 173 of file p_MemAdd.h.

175{ \
177 const unsigned long _l = (unsigned long) length; \
178 unsigned long _i = 0; \
179 \
180 do \
181 { \
182 _r[_i] += _s[_i]; \
183 _i++; \
184 } \
185 while (_i != _l); \
186} \
187while (0)

◆ p_MemAdd_LengthOne

#define p_MemAdd_LengthOne (   r,
  s,
  length 
)    _p_MemAdd_LengthOne(r, s)

Definition at line 122 of file p_MemAdd.h.

◆ p_MemAdd_LengthSeven

#define p_MemAdd_LengthSeven (   r,
  s,
  length 
)
Value:

Definition at line 158 of file p_MemAdd.h.

160{ \
163} \
164while (0)

◆ p_MemAdd_LengthSix

#define p_MemAdd_LengthSix (   r,
  s,
  length 
)
Value:

Definition at line 151 of file p_MemAdd.h.

153{ \
156} \
157while (0)

◆ p_MemAdd_LengthThree

#define p_MemAdd_LengthThree (   r,
  s,
  length 
)
Value:

Definition at line 130 of file p_MemAdd.h.

132{ \
135} \
136while (0)

◆ p_MemAdd_LengthTwo

#define p_MemAdd_LengthTwo (   r,
  s,
  length 
)
Value:

Definition at line 123 of file p_MemAdd.h.

125{ \
128} \
129while (0)

◆ p_MemAddSub_LengthGeneral

#define p_MemAddSub_LengthGeneral (   r,
  s,
  t,
  length 
)
Value:
do \
{ \
const unsigned long _l = (unsigned long) length; \
unsigned long _i = 0; \
\
do \
{ \
_r[_i] += _s[_i] - _t[_i]; \
_i++; \
} \
while (_i != _l); \
} \
while (0)

Definition at line 312 of file p_MemAdd.h.

314{ \
316 const unsigned long _l = (unsigned long) length; \
317 unsigned long _i = 0; \
318 \
319 do \
320 { \
321 _r[_i] += _s[_i] - _t[_i]; \
322 _i++; \
323 } \
324 while (_i != _l); \
325} \
326while (0)

◆ p_MemDiff_LengthEight

#define p_MemDiff_LengthEight (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 254 of file p_MemAdd.h.

256{ \
259} \
260while (0)

◆ p_MemDiff_LengthFive

#define p_MemDiff_LengthFive (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 233 of file p_MemAdd.h.

235{ \
238} \
239while (0)

◆ p_MemDiff_LengthFour

#define p_MemDiff_LengthFour (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 226 of file p_MemAdd.h.

228{ \
231} \
232while (0)

◆ p_MemDiff_LengthGeneral

#define p_MemDiff_LengthGeneral (   r,
  s1,
  s2,
  length 
)
Value:
do \
{ \
const unsigned long _l = (unsigned long) length; \
unsigned long _i = 0; \
\
do \
{ \
_r[_i] = _s1[_i] - _s2[_i]; \
_i++; \
} \
while (_i != _l); \
} \
while (0)

Definition at line 262 of file p_MemAdd.h.

264{ \
266 const unsigned long _l = (unsigned long) length; \
267 unsigned long _i = 0; \
268 \
269 do \
270 { \
271 _r[_i] = _s1[_i] - _s2[_i]; \
272 _i++; \
273 } \
274 while (_i != _l); \
275} \
276while (0)

◆ p_MemDiff_LengthOne

#define p_MemDiff_LengthOne (   r,
  s1,
  s2,
  length 
)    _p_MemDiff_LengthOne(r, s1, s2)

Definition at line 211 of file p_MemAdd.h.

◆ p_MemDiff_LengthSeven

#define p_MemDiff_LengthSeven (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 247 of file p_MemAdd.h.

249{ \
252} \
253while (0)

◆ p_MemDiff_LengthSix

#define p_MemDiff_LengthSix (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 240 of file p_MemAdd.h.

242{ \
245} \
246while (0)

◆ p_MemDiff_LengthThree

#define p_MemDiff_LengthThree (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 219 of file p_MemAdd.h.

221{ \
224} \
225while (0)

◆ p_MemDiff_LengthTwo

#define p_MemDiff_LengthTwo (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 212 of file p_MemAdd.h.

214{ \
217} \
218while (0)

◆ p_MemSub_LengthGeneral

#define p_MemSub_LengthGeneral (   r,
  s,
  length 
)
Value:
do \
{ \
const unsigned long _l = (unsigned long) length; \
unsigned long _i = 0; \
\
do \
{ \
_r[_i] -= _s[_i]; \
_i++; \
} \
while (_i != _l); \
} \
while (0)

Definition at line 291 of file p_MemAdd.h.

293{ \
295 const unsigned long _l = (unsigned long) length; \
296 unsigned long _i = 0; \
297 \
298 do \
299 { \
300 _r[_i] -= _s[_i]; \
301 _i++; \
302 } \
303 while (_i != _l); \
304} \
305while (0)

◆ p_MemSum_LengthEight

#define p_MemSum_LengthEight (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 78 of file p_MemAdd.h.

80{ \
83} \
84while (0)

◆ p_MemSum_LengthFive

#define p_MemSum_LengthFive (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 57 of file p_MemAdd.h.

59{ \
62} \
63while (0)

◆ p_MemSum_LengthFour

#define p_MemSum_LengthFour (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 50 of file p_MemAdd.h.

52{ \
55} \
56while (0)

◆ p_MemSum_LengthGeneral

#define p_MemSum_LengthGeneral (   r,
  s1,
  s2,
  length 
)
Value:
do \
{ \
const unsigned long _l = (unsigned long) length; \
unsigned long _i = 0; \
\
do \
{ \
_r[_i] = _s1[_i] + _s2[_i]; \
_i++; \
} \
while (_i != _l); \
} \
while (0)

Definition at line 86 of file p_MemAdd.h.

88{ \
90 const unsigned long _l = (unsigned long) length; \
91 unsigned long _i = 0; \
92 \
93 do \
94 { \
95 _r[_i] = _s1[_i] + _s2[_i]; \
96 _i++; \
97 } \
98 while (_i != _l); \
99} \
100while (0)

◆ p_MemSum_LengthOne

#define p_MemSum_LengthOne (   r,
  s1,
  s2,
  length 
)    _p_MemSum_LengthOne(r, s1, s2)

Definition at line 35 of file p_MemAdd.h.

◆ p_MemSum_LengthSeven

#define p_MemSum_LengthSeven (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 71 of file p_MemAdd.h.

73{ \
76} \
77while (0)

◆ p_MemSum_LengthSix

#define p_MemSum_LengthSix (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 64 of file p_MemAdd.h.

66{ \
69} \
70while (0)

◆ p_MemSum_LengthThree

#define p_MemSum_LengthThree (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 43 of file p_MemAdd.h.

45{ \
48} \
49while (0)

◆ p_MemSum_LengthTwo

#define p_MemSum_LengthTwo (   r,
  s1,
  s2,
  length 
)
Value:

Definition at line 36 of file p_MemAdd.h.

38{ \
41} \
42while (0)