IceUtils.h
Go to the documentation of this file.
1 
8 
11 // Include Guard
12 #ifndef __ICEUTILS_H__
13 #define __ICEUTILS_H__
14 
15  #define START_RUNONCE { static bool __RunOnce__ = false; if(!__RunOnce__){
16  #define END_RUNONCE __RunOnce__ = true;}}
17 
21  {
22  n = ((n >> 1) & 0x55555555) | ((n << 1) & 0xaaaaaaaa);
23  n = ((n >> 2) & 0x33333333) | ((n << 2) & 0xcccccccc);
24  n = ((n >> 4) & 0x0f0f0f0f) | ((n << 4) & 0xf0f0f0f0);
25  n = ((n >> 8) & 0x00ff00ff) | ((n << 8) & 0xff00ff00);
26  n = ((n >> 16) & 0x0000ffff) | ((n << 16) & 0xffff0000);
27  // Etc for larger intergers (64 bits in Java)
28  // NOTE: the >> operation must be unsigned! (>>> in java)
29  }
30 
33  {
34  // This relies of the fact that the count of n bits can NOT overflow
35  // an n bit interger. EG: 1 bit count takes a 1 bit interger, 2 bit counts
36  // 2 bit interger, 3 bit count requires only a 2 bit interger.
37  // So we add all bit pairs, then each nible, then each byte etc...
38  n = (n & 0x55555555) + ((n & 0xaaaaaaaa) >> 1);
39  n = (n & 0x33333333) + ((n & 0xcccccccc) >> 2);
40  n = (n & 0x0f0f0f0f) + ((n & 0xf0f0f0f0) >> 4);
41  n = (n & 0x00ff00ff) + ((n & 0xff00ff00) >> 8);
42  n = (n & 0x0000ffff) + ((n & 0xffff0000) >> 16);
43  // Etc for larger intergers (64 bits in Java)
44  // NOTE: the >> operation must be unsigned! (>>> in java)
45  return n;
46  }
47 
50  {
51  bits = bits - ((bits >> 1) & 0x55555555);
52  bits = ((bits >> 2) & 0x33333333) + (bits & 0x33333333);
53  bits = ((bits >> 4) + bits) & 0x0F0F0F0F;
54  return (bits * 0x01010101) >> 24;
55  }
56 
63  {
64  n = ( n & 0x0000ffff) | (( n & 0xffff0000) << 16);
65  n = ( n & 0x000000ff) | (( n & 0x0000ff00) << 8);
66  n = ( n & 0x000f000f) | (( n & 0x00f000f0) << 4);
67  n = ( n & 0x03030303) | (( n & 0x0c0c0c0c) << 2);
68  n = ( n & 0x11111111) | (( n & 0x22222222) << 1);
69  }
70 
71  // Next Largest Power of 2
72  // Given a binary integer value x, the next largest power of 2 can be computed by a SWAR algorithm
73  // that recursively "folds" the upper bits into the lower bits. This process yields a bit vector with
74  // the same most significant 1 as x, but all 1's below it. Adding 1 to that value yields the next
75  // largest power of 2. For a 32-bit value:
77  {
78  x |= (x >> 1);
79  x |= (x >> 2);
80  x |= (x >> 4);
81  x |= (x >> 8);
82  x |= (x >> 16);
83  return x+1;
84  }
85 
87  inline_ bool IsPowerOfTwo(udword n) { return ((n&(n-1))==0); }
88 
90  inline_ void ZeroLeastSetBit(udword& n) { n&=(n-1); }
91 
93  inline_ void SetLeastNBits(udword& x, udword n) { x|=~(~0<<n); }
94 
99  inline_ void Swap(udword& x, udword& y) { x ^= y; y ^= x; x ^= y; }
100 
115  inline_ char LittleEndian() { int i = 1; return *((char*)&i); }
116 
118  inline_ udword abs_(sdword x) { sdword y= x >> 31; return (x^y)-y; }
119 
121  inline_ sdword min_(sdword a, sdword b) { sdword delta = b-a; return a + (delta&(delta>>31)); }
122 
123  // Determine if one of the bytes in a 4 byte word is zero
124  inline_ BOOL HasNullByte(udword x) { return ((x + 0xfefefeff) & (~x) & 0x80808080); }
125 
126  // To find the smallest 1 bit in a word EG: ~~~~~~10---0 => 0----010---0
127  inline_ udword LowestOneBit(udword w) { return ((w) & (~(w)+1)); }
128 // inline_ udword LowestOneBit_(udword w) { return ((w) & (-(w))); }
129 
130  // Most Significant 1 Bit
131  // Given a binary integer value x, the most significant 1 bit (highest numbered element of a bit set)
132  // can be computed using a SWAR algorithm that recursively "folds" the upper bits into the lower bits.
133  // This process yields a bit vector with the same most significant 1 as x, but all 1's below it.
134  // Bitwise AND of the original value with the complement of the "folded" value shifted down by one
135  // yields the most significant bit. For a 32-bit value:
137  {
138  x |= (x >> 1);
139  x |= (x >> 2);
140  x |= (x >> 4);
141  x |= (x >> 8);
142  x |= (x >> 16);
143  return (x & ~(x >> 1));
144  }
145 
146  /*
147  "Just call it repeatedly with various input values and always with the same variable as "memory".
148  The sharpness determines the degree of filtering, where 0 completely filters out the input, and 1
149  does no filtering at all.
150 
151  I seem to recall from college that this is called an IIR (Infinite Impulse Response) filter. As opposed
152  to the more typical FIR (Finite Impulse Response).
153 
154  Also, I'd say that you can make more intelligent and interesting filters than this, for example filters
155  that remove wrong responses from the mouse because it's being moved too fast. You'd want such a filter
156  to be applied before this one, of course."
157 
158  (JCAB on Flipcode)
159  */
160  inline_ float FeedbackFilter(float val, float& memory, float sharpness)
161  {
162  ASSERT(sharpness>=0.0f && sharpness<=1.0f && "Invalid sharpness value in feedback filter");
163  if(sharpness<0.0f) sharpness = 0.0f;
164  else if(sharpness>1.0f) sharpness = 1.0f;
165  return memory = val * sharpness + memory * (1.0f - sharpness);
166  }
167 
172  {
173 // ASSERT(abs(x) < (int)((1<<31u)-32767));
174 
175  int delta = 32767 - x;
176  x += (delta>>31) & delta;
177  delta = x + 32768;
178  x -= (delta>>31) & delta;
179  return x;
180  }
181 
182  // Generic functions
183  template<class Type> inline_ void TSwap(Type& a, Type& b) { const Type c = a; a = b; b = c; }
184  template<class Type> inline_ Type TClamp(const Type& x, const Type& lo, const Type& hi) { return ((x<lo) ? lo : (x>hi) ? hi : x); }
185 
186  template<class Type> inline_ void TSort(Type& a, Type& b)
187  {
188  if(a>b) TSwap(a, b);
189  }
190 
191  template<class Type> inline_ void TSort(Type& a, Type& b, Type& c)
192  {
193  if(a>b) TSwap(a, b);
194  if(b>c) TSwap(b, c);
195  if(a>b) TSwap(a, b);
196  if(b>c) TSwap(b, c);
197  }
198 
199  // Prevent nasty user-manipulations (strategy borrowed from Charles Bloom)
200 // #define PREVENT_COPY(curclass) void operator = (const curclass& object) { ASSERT(!"Bad use of operator ="); }
201  // ... actually this is better !
202  #define PREVENT_COPY(cur_class) private: cur_class(const cur_class& object); cur_class& operator=(const cur_class& object);
203 
205  #define OFFSET_OF(Class, Member) (size_t)&(((Class*)0)->Member)
206  #define ARRAYSIZE(p) (sizeof(p)/sizeof(p[0]))
208 
210 
218 
219  #define IS_ALIGNED_2(x) ((x&1)==0)
220  #define IS_ALIGNED_4(x) ((x&3)==0)
221  #define IS_ALIGNED_8(x) ((x&7)==0)
222 
223  inline_ void _prefetch(void const* ptr) { (void)*(char const volatile *)ptr; }
224 
225  // Compute implicit coords from an index:
226  // The idea is to get back 2D coords from a 1D index.
227  // For example:
228  //
229  // 0 1 2 ... nbu-1
230  // nbu nbu+1 i ...
231  //
232  // We have i, we're looking for the equivalent (u=2, v=1) location.
233  // i = u + v*nbu
234  // <=> i/nbu = u/nbu + v
235  // Since 0 <= u < nbu, u/nbu = 0 (integer)
236  // Hence: v = i/nbu
237  // Then we simply put it back in the original equation to compute u = i - v*nbu
239  {
240  v = i / nbu;
241  u = i - (v * nbu);
242  }
243 
244  // In 3D: i = u + v*nbu + w*nbu*nbv
245  // <=> i/(nbu*nbv) = u/(nbu*nbv) + v/nbv + w
246  // u/(nbu*nbv) is null since u/nbu was null already.
247  // v/nbv is null as well for the same reason.
248  // Hence w = i/(nbu*nbv)
249  // Then we're left with a 2D problem: i' = i - w*nbu*nbv = u + v*nbu
250  inline_ void Compute3DCoords(udword& u, udword& v, udword& w, udword i, udword nbu, udword nbu_nbv)
251  {
252  w = i / (nbu_nbv);
253  Compute2DCoords(u, v, i - (w * nbu_nbv), nbu);
254  }
255 
256 #endif // __ICEUTILS_H__
int c
Definition: autoplay.py:16
signed int sdword
sizeof(sdword) must be 4
Definition: IceTypes.h:64
* x
Definition: IceUtils.h:98
png_voidp ptr
Definition: png.h:2063
inline_ sdword min_(sdword a, sdword b)
Definition: IceUtils.h:121
inline_ int ClampToInt16(int x)
Definition: IceUtils.h:171
FUNCTION ICECORE_API udword Alignment(udword address)
#define FUNCTION
#define inline_
inline_ bool IsPowerOfTwo(udword n)
Test to see if a number is an exact power of two (from Steve Baker&#39;s Cute Code Collection) ...
Definition: IceUtils.h:87
inline_ void ReverseBits(udword &n)
Definition: IceUtils.h:20
inline_ void _prefetch(void const *ptr)
Definition: IceUtils.h:223
inline_ void SpreadBits(udword &n)
Definition: IceUtils.h:62
png_uint_32 i
Definition: png.h:2735
long b
Definition: jpegint.h:371
#define ICECORE_API
inline_ udword abs_(sdword x)
Alternative min function.
Definition: IceUtils.h:118
int BOOL
Another boolean type.
Definition: IceTypes.h:102
unsigned int udword
sizeof(udword) must be 4
Definition: IceTypes.h:65
inline_ void Compute2DCoords(udword &u, udword &v, udword i, udword nbu)
Definition: IceUtils.h:238
inline_ BOOL HasNullByte(udword x)
Definition: IceUtils.h:124
inline_ udword CountBits(udword n)
Count the number of &#39;1&#39; bits in a 32 bit word (from Steve Baker&#39;s Cute Code Collection) ...
Definition: IceUtils.h:32
inline_ udword nlpo2(udword x)
Definition: IceUtils.h:76
typedef void(PNGAPI *png_error_ptr) PNGARG((png_structp
inline_ Type TClamp(const Type &x, const Type &lo, const Type &hi)
Definition: IceUtils.h:184
inline_ void ZeroLeastSetBit(udword &n)
Zero the least significant &#39;1&#39; bit in a word. (from Steve Baker&#39;s Cute Code Collection) ...
Definition: IceUtils.h:90
int val
Definition: jpeglib.h:956
inline_ udword CountBits2(udword bits)
Even faster?
Definition: IceUtils.h:49
inline_ void TSort(Type &a, Type &b)
Definition: IceUtils.h:186
inline_ void TSwap(Type &a, Type &b)
Definition: IceUtils.h:183
#define ASSERT(exp)
Definition: OPC_IceHook.h:24
inline_ udword LowestOneBit(udword w)
Definition: IceUtils.h:127
inline_ float FeedbackFilter(float val, float &memory, float sharpness)
Definition: IceUtils.h:160
inline_ char LittleEndian()
Alternative abs function.
Definition: IceUtils.h:115
inline_ udword msb32(udword x)
Definition: IceUtils.h:136
inline_ void Compute3DCoords(udword &u, udword &v, udword &w, udword i, udword nbu, udword nbu_nbv)
Definition: IceUtils.h:250
* y
Definition: IceUtils.h:97
inline_ void SetLeastNBits(udword &x, udword n)
Set the least significant N bits in a word. (from Steve Baker&#39;s Cute Code Collection) ...
Definition: IceUtils.h:93
*inline_ void Swap(udword &x, udword &y)
Definition: IceUtils.h:99


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Thu Sep 8 2022 02:24:03