| 1 |
2 |
rudi |
/////////////////////////////////////////////////////////////////////
|
| 2 |
|
|
//// ////
|
| 3 |
|
|
//// fptpg.c ////
|
| 4 |
|
|
//// Floating Point Test Pattern Generator ////
|
| 5 |
|
|
//// ////
|
| 6 |
|
|
//// Author: Rudolf Usselmann ////
|
| 7 |
|
|
//// russelmann@hotmail.com ////
|
| 8 |
|
|
//// ////
|
| 9 |
|
|
/////////////////////////////////////////////////////////////////////
|
| 10 |
|
|
//// ////
|
| 11 |
|
|
//// Copyright (C) 2000 Rudolf Usselmann ////
|
| 12 |
|
|
//// russelmann@hotmail.com ////
|
| 13 |
|
|
//// ////
|
| 14 |
|
|
//// This source file may be used and distributed without ////
|
| 15 |
|
|
//// restriction provided that this copyright statement is not ////
|
| 16 |
|
|
//// removed from the file and that any derivative work contains ////
|
| 17 |
|
|
//// the original copyright notice and the associated disclaimer.////
|
| 18 |
|
|
//// ////
|
| 19 |
|
|
//// THIS SOURCE FILE IS PROVIDED "AS IS" AND WITHOUT ANY ////
|
| 20 |
|
|
//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT ////
|
| 21 |
|
|
//// LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND ////
|
| 22 |
|
|
//// FITNESS FOR A PARTICULAR PURPOSE. ////
|
| 23 |
|
|
//// ////
|
| 24 |
|
|
/////////////////////////////////////////////////////////////////////
|
| 25 |
|
|
|
| 26 |
|
|
|
| 27 |
|
|
#include "milieu.h"
|
| 28 |
|
|
#include "softfloat.h"
|
| 29 |
|
|
|
| 30 |
|
|
// Global vars ...
|
| 31 |
|
|
int verb=0;
|
| 32 |
|
|
int quiet=0;
|
| 33 |
|
|
int pat=0;
|
| 34 |
|
|
int large=0;
|
| 35 |
|
|
int append=0;
|
| 36 |
|
|
int rall=0;
|
| 37 |
|
|
char *ofile=0;
|
| 38 |
|
|
|
| 39 |
|
|
// Prototypes ...
|
| 40 |
|
|
float32 get_fp();
|
| 41 |
|
|
int arop(int , int );
|
| 42 |
|
|
float32 get_pat(int );
|
| 43 |
|
|
float32 get_pat0(int );
|
| 44 |
|
|
float32 get_pat1(int );
|
| 45 |
|
|
float32 get_pat2(int );
|
| 46 |
|
|
|
| 47 |
|
|
|
| 48 |
|
|
main(int argc, char **argv)
|
| 49 |
|
|
{
|
| 50 |
|
|
int i;
|
| 51 |
|
|
int count=25;
|
| 52 |
|
|
int ar = 0;
|
| 53 |
|
|
int seed = 12345678;
|
| 54 |
|
|
|
| 55 |
|
|
float_rounding_mode = float_round_nearest_even; // Default Rounding Mode
|
| 56 |
|
|
|
| 57 |
|
|
if(argc<2) {
|
| 58 |
|
|
printf("Usage:\n");
|
| 59 |
|
|
printf(" -n <count> Specifies the number of tests\n");
|
| 60 |
|
|
printf(" vectors to generate. Default: 25.\n");
|
| 61 |
|
|
printf(" -v Verbose\n");
|
| 62 |
|
|
printf(" -q Quiet\n");
|
| 63 |
|
|
printf(" -a Append to output file name. Default: Overwrite\n");
|
| 64 |
|
|
printf(" -l Use large numbers\n");
|
| 65 |
|
|
printf(" -p N Use built in patterns. N=Patter Number:\n");
|
| 66 |
|
|
printf(" 0 = Min/Max Bit patters, normalized numbers only (Max 92416 Vectors)\n");
|
| 67 |
|
|
printf(" 1 = Min/Max Bit patters, including denormalized numbers (Max 92416 Vectors)\n");
|
| 68 |
|
|
printf(" 2 = Bit patterns test vectors (Max 15376 Vectors)\n");
|
| 69 |
|
|
printf(" -o <filename> Dump patterns to <filename>\n");
|
| 70 |
|
|
printf(" -r N Round Option. Where N is one of:\n");
|
| 71 |
|
|
printf(" 0 = float_round_nearest_eve (Default)\n");
|
| 72 |
|
|
printf(" 1 = float_round_down\n");
|
| 73 |
|
|
printf(" 2 = float_round_up\n");
|
| 74 |
|
|
printf(" 3 = float_round_to_zero\n");
|
| 75 |
|
|
printf(" -m N Generate Test patters for operation N.\n");
|
| 76 |
|
|
printf(" Where N is a combination of:\n");
|
| 77 |
5 |
rudi |
printf(" 1 = Add operations\n");
|
| 78 |
|
|
printf(" 2 = Subtract Operations\n");
|
| 79 |
|
|
printf(" 4 = Multiply Operations\n");
|
| 80 |
|
|
printf(" 8 = Divide operations\n");
|
| 81 |
|
|
printf(" 16 = Integer to Floating Point Conversion\n");
|
| 82 |
|
|
printf(" 32 = Floating Point to Integer Conversion\n");
|
| 83 |
|
|
printf(" 64 = Remainder Function\n");
|
| 84 |
2 |
rudi |
printf(" -s N Use N as seed for rand() functions.\n");
|
| 85 |
|
|
printf(" -R Randomize rounding mode.\n");
|
| 86 |
|
|
return(0);
|
| 87 |
|
|
}
|
| 88 |
|
|
|
| 89 |
|
|
i=1;
|
| 90 |
|
|
|
| 91 |
|
|
while((argc-1)>=i) {
|
| 92 |
|
|
|
| 93 |
|
|
if(strcmp(argv[i],"-v")==0) verb=1;
|
| 94 |
|
|
else
|
| 95 |
|
|
if(strcmp(argv[i],"-q")==0) quiet=1;
|
| 96 |
|
|
else
|
| 97 |
|
|
if(strcmp(argv[i],"-R")==0) rall=1;
|
| 98 |
|
|
else
|
| 99 |
|
|
if(strcmp(argv[i],"-p")==0) {
|
| 100 |
|
|
i++;
|
| 101 |
|
|
pat = atoi(argv[i]) + 1;
|
| 102 |
|
|
if(pat>3 | pat<0) {
|
| 103 |
|
|
printf("ERROR: 'pattern' out of range (%0d), resetting to pattern 0.\n",pat);
|
| 104 |
|
|
pat = 1;
|
| 105 |
|
|
}
|
| 106 |
|
|
}
|
| 107 |
|
|
else
|
| 108 |
|
|
if(strcmp(argv[i],"-l")==0) large=1;
|
| 109 |
|
|
else
|
| 110 |
|
|
if(strcmp(argv[i],"-ll")==0) large=2;
|
| 111 |
|
|
else
|
| 112 |
|
|
if(strcmp(argv[i],"-a")==0) append=1;
|
| 113 |
|
|
else
|
| 114 |
|
|
if(strcmp(argv[i],"-n")==0) {
|
| 115 |
|
|
i++;
|
| 116 |
|
|
count = atoi(argv[i]);
|
| 117 |
|
|
if(count<0 | count>1000000) {
|
| 118 |
|
|
printf("ERROR: 'count' out of range (%0d), resetting to default.\n",count);
|
| 119 |
|
|
count=25;
|
| 120 |
|
|
}
|
| 121 |
|
|
}
|
| 122 |
|
|
else
|
| 123 |
|
|
if(strcmp(argv[i],"-o")==0) {
|
| 124 |
|
|
i++;
|
| 125 |
|
|
ofile = argv[i];
|
| 126 |
|
|
}
|
| 127 |
|
|
else
|
| 128 |
|
|
if(strcmp(argv[i],"-m")==0) {
|
| 129 |
|
|
i++;
|
| 130 |
|
|
ar = atoi(argv[i]);
|
| 131 |
|
|
}
|
| 132 |
|
|
else
|
| 133 |
|
|
if(strcmp(argv[i],"-r")==0) {
|
| 134 |
|
|
i++;
|
| 135 |
|
|
float_rounding_mode = atoi(argv[i]);
|
| 136 |
|
|
}
|
| 137 |
|
|
else
|
| 138 |
|
|
if(strcmp(argv[i],"-s")==0) {
|
| 139 |
|
|
i++;
|
| 140 |
|
|
seed = atoi(argv[i]);
|
| 141 |
|
|
}
|
| 142 |
|
|
else
|
| 143 |
|
|
printf("Unknown Option: %s\n\n",argv[i]);
|
| 144 |
|
|
i++;
|
| 145 |
|
|
}
|
| 146 |
|
|
|
| 147 |
|
|
srand( seed );
|
| 148 |
|
|
|
| 149 |
|
|
if(!quiet) {
|
| 150 |
5 |
rudi |
printf("\n Floating Point Test Vector Generation V1.6\n");
|
| 151 |
2 |
rudi |
printf("\t by Rudolf Usselmann rudi@asics.ws\n\n");
|
| 152 |
|
|
|
| 153 |
|
|
switch(float_rounding_mode) {
|
| 154 |
|
|
case 0: printf("Rounding mode: float_round_nearest_even\n"); break;
|
| 155 |
|
|
case 1: printf("Rounding mode: float_round_down\n"); break;
|
| 156 |
|
|
case 2: printf("Rounding mode: float_round_up\n"); break;
|
| 157 |
|
|
case 3: printf("Rounding mode: float_round_to_zero\n"); break;
|
| 158 |
|
|
|
| 159 |
|
|
default: printf("Rounding mode: Unknown (%0d)\n", float_rounding_mode ); break;
|
| 160 |
|
|
}
|
| 161 |
|
|
}
|
| 162 |
|
|
|
| 163 |
|
|
if(count==25) {
|
| 164 |
|
|
|
| 165 |
5 |
rudi |
if( (ar & 0x10) | (ar & 0x20) ) {
|
| 166 |
|
|
|
| 167 |
|
|
if(pat==1) count = 304;
|
| 168 |
|
|
else
|
| 169 |
|
|
if(pat==2) count = 304;
|
| 170 |
|
|
else
|
| 171 |
|
|
if(pat==3) count = 124;
|
| 172 |
|
|
|
| 173 |
|
|
} else {
|
| 174 |
|
|
|
| 175 |
|
|
if(pat==1) count = 92416;
|
| 176 |
|
|
else
|
| 177 |
|
|
if(pat==2) count = 92416;
|
| 178 |
|
|
else
|
| 179 |
|
|
if(pat==3) count = 15376;
|
| 180 |
|
|
|
| 181 |
|
|
}
|
| 182 |
|
|
|
| 183 |
2 |
rudi |
}
|
| 184 |
|
|
|
| 185 |
|
|
if(ar) arop(count,ar);
|
| 186 |
|
|
|
| 187 |
|
|
return(0);
|
| 188 |
|
|
}
|
| 189 |
|
|
|
| 190 |
|
|
|
| 191 |
|
|
int arop(int count, int op) {
|
| 192 |
|
|
float32 f1, f2, f3, f4;
|
| 193 |
|
|
int i;
|
| 194 |
|
|
int fp;
|
| 195 |
|
|
char *mode;
|
| 196 |
|
|
int add=0;
|
| 197 |
|
|
int sub=0;
|
| 198 |
|
|
int mul=0;
|
| 199 |
|
|
int div=0;
|
| 200 |
5 |
rudi |
int i2f=0;
|
| 201 |
|
|
int f2i=0;
|
| 202 |
|
|
int rem=0;
|
| 203 |
2 |
rudi |
int oper;
|
| 204 |
|
|
int err;
|
| 205 |
|
|
int err_count=0;
|
| 206 |
5 |
rudi |
int tmp;
|
| 207 |
2 |
rudi |
|
| 208 |
|
|
if(!quiet) printf("\nGenerating %0d Arithmetic test vectors ...\n",count);
|
| 209 |
|
|
|
| 210 |
|
|
if(append) mode = "a";
|
| 211 |
|
|
else mode = "w";
|
| 212 |
|
|
if(ofile==0) ofile = "ar.hex";
|
| 213 |
|
|
|
| 214 |
|
|
fp = fopen(ofile,mode);
|
| 215 |
|
|
if(fp == 0) {
|
| 216 |
|
|
printf("ERROR: Could not create file '%s'.\n",ofile);
|
| 217 |
|
|
return(-1);
|
| 218 |
|
|
}
|
| 219 |
|
|
|
| 220 |
|
|
if(!quiet) {
|
| 221 |
5 |
rudi |
if(op & 0x01) printf("Add OP\n");
|
| 222 |
|
|
if(op & 0x02) printf("Sub OP\n");
|
| 223 |
|
|
if(op & 0x04) printf("Mul OP\n");
|
| 224 |
|
|
if(op & 0x08) printf("Div OP\n");
|
| 225 |
|
|
if(op & 0x10) printf("int2float\n");
|
| 226 |
|
|
if(op & 0x20) printf("float2int\n");
|
| 227 |
|
|
if(op & 0x40) printf("Remainder\n");
|
| 228 |
2 |
rudi |
}
|
| 229 |
|
|
|
| 230 |
5 |
rudi |
if(op & 0x01) add=1;
|
| 231 |
|
|
if(op & 0x02) sub=1;
|
| 232 |
|
|
if(op & 0x04) mul=1;
|
| 233 |
|
|
if(op & 0x08) div=1;
|
| 234 |
|
|
if(op & 0x10) i2f=1;
|
| 235 |
|
|
if(op & 0x20) f2i=1;
|
| 236 |
|
|
if(op & 0x40) rem=1;
|
| 237 |
2 |
rudi |
|
| 238 |
|
|
f1 = get_pat(0); // Initialize pattern generator ...
|
| 239 |
|
|
|
| 240 |
|
|
for(i=0;i<count;i++) {
|
| 241 |
|
|
|
| 242 |
|
|
err = 0;
|
| 243 |
|
|
|
| 244 |
|
|
if(pat>0) {
|
| 245 |
|
|
f1 = get_pat(1);
|
| 246 |
|
|
f2 = get_pat(2);
|
| 247 |
|
|
} else {
|
| 248 |
|
|
f1 = get_fp();
|
| 249 |
|
|
f2 = get_fp();
|
| 250 |
|
|
}
|
| 251 |
|
|
|
| 252 |
|
|
|
| 253 |
|
|
if(rall) float_rounding_mode = (rand() % 4);
|
| 254 |
|
|
|
| 255 |
|
|
|
| 256 |
|
|
oper = -1;
|
| 257 |
|
|
while(oper == -1) {
|
| 258 |
5 |
rudi |
float_exception_flags = 0; // Reset Exceptions
|
| 259 |
2 |
rudi |
|
| 260 |
5 |
rudi |
if( (rand() % 8)==6 & rem) {
|
| 261 |
|
|
oper = 0x40;
|
| 262 |
|
|
f3 = float32_rem( f1, f2 );
|
| 263 |
|
|
float_exception_flags = 0; // Reset Exceptions
|
| 264 |
|
|
f3 = float32_rem( f1, f2 );
|
| 265 |
|
|
}
|
| 266 |
|
|
|
| 267 |
|
|
if( (rand() % 8)==5 & f2i) {
|
| 268 |
|
|
oper = 0x20;
|
| 269 |
|
|
f3 = float32_to_int32( f1 );
|
| 270 |
|
|
float_exception_flags = 0; // Reset Exceptions
|
| 271 |
|
|
f3 = float32_to_int32( f1 );
|
| 272 |
|
|
f2 = 0;
|
| 273 |
|
|
}
|
| 274 |
|
|
|
| 275 |
|
|
if( (rand() % 8)==4 & i2f) {
|
| 276 |
|
|
oper = 0x10;
|
| 277 |
|
|
|
| 278 |
|
|
|
| 279 |
|
|
tmp = (int) f1;
|
| 280 |
|
|
|
| 281 |
|
|
|
| 282 |
|
|
f3 = int32_to_float32( tmp );
|
| 283 |
|
|
float_exception_flags = 0; // Reset Exceptions
|
| 284 |
|
|
f3 = int32_to_float32( tmp );
|
| 285 |
|
|
f2 =0;
|
| 286 |
|
|
}
|
| 287 |
|
|
|
| 288 |
|
|
|
| 289 |
|
|
if( (rand() % 8)==3 & div) {
|
| 290 |
|
|
oper = 0x08;
|
| 291 |
2 |
rudi |
f3 = float32_div( f1, f2);
|
| 292 |
|
|
float_exception_flags = 0; // Reset Exceptions
|
| 293 |
|
|
f3 = float32_div( f1, f2);
|
| 294 |
|
|
|
| 295 |
|
|
//*( (float *) &f4 ) = *( (float *) &f1 ) / *( (float *) &f2 );
|
| 296 |
|
|
//if( f4 != f3) {
|
| 297 |
|
|
// err = 1;
|
| 298 |
|
|
// printf("FP Div Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
| 299 |
|
|
// }
|
| 300 |
|
|
}
|
| 301 |
|
|
|
| 302 |
5 |
rudi |
if( (rand() % 8)==2 & mul) {
|
| 303 |
|
|
oper = 0x04;
|
| 304 |
2 |
rudi |
f3 = float32_mul( f1, f2);
|
| 305 |
|
|
float_exception_flags = 0; // Reset Exceptions
|
| 306 |
|
|
f3 = float32_mul( f1, f2);
|
| 307 |
|
|
|
| 308 |
|
|
//*( (float *) &f4 ) = *( (float *) &f1 ) * *( (float *) &f2 );
|
| 309 |
|
|
//if( f4 != f3) {
|
| 310 |
|
|
// err = 1;
|
| 311 |
|
|
// printf("FP Mul Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
| 312 |
|
|
// }
|
| 313 |
|
|
}
|
| 314 |
|
|
|
| 315 |
5 |
rudi |
if( (rand() % 8)==1 & sub) {
|
| 316 |
|
|
oper = 0x02;
|
| 317 |
2 |
rudi |
f3 = float32_sub( f1, f2);
|
| 318 |
|
|
float_exception_flags = 0; // Reset Exceptions
|
| 319 |
|
|
f3 = float32_sub( f1, f2);
|
| 320 |
|
|
|
| 321 |
|
|
//*( (float *) &f4 ) = *( (float *) &f1 ) - *( (float *) &f2 );
|
| 322 |
|
|
//if( f4 != f3) {
|
| 323 |
|
|
// err = 1;
|
| 324 |
|
|
// printf("FP Sub Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
| 325 |
|
|
// }
|
| 326 |
|
|
}
|
| 327 |
|
|
|
| 328 |
5 |
rudi |
if( (rand() % 8)==0 & add) {
|
| 329 |
|
|
oper = 0x01;
|
| 330 |
2 |
rudi |
f3 = float32_add( f1, f2);
|
| 331 |
|
|
float_exception_flags = 0; // Reset Exceptions
|
| 332 |
|
|
f3 = float32_add( f1, f2);
|
| 333 |
|
|
|
| 334 |
|
|
//*( (float *) &f4 ) = *( (float *) &f1 ) + *( (float *) &f2 );
|
| 335 |
|
|
//if( f4 != f3) {
|
| 336 |
|
|
// err = 1;
|
| 337 |
|
|
// printf("FP Add Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
| 338 |
|
|
// }
|
| 339 |
|
|
}
|
| 340 |
|
|
|
| 341 |
|
|
}
|
| 342 |
|
|
|
| 343 |
|
|
if(err) err_count++;
|
| 344 |
|
|
|
| 345 |
|
|
if(!err) {
|
| 346 |
|
|
|
| 347 |
|
|
//if(float_exception_flags != 0)
|
| 348 |
|
|
// printf("Exceptions: %x\n",float_exception_flags);
|
| 349 |
|
|
|
| 350 |
|
|
|
| 351 |
5 |
rudi |
if(verb) printf("rmode: %01x, except: %02x, oper: %02x opa: %08x, opb: %08x res: %08x\n", float_rounding_mode, float_exception_flags, oper, f1, f2, f3);
|
| 352 |
|
|
fprintf(fp,"%01x%02x%02x%08x%08x%08x\n", float_rounding_mode, float_exception_flags, oper, f1, f2, f3);
|
| 353 |
2 |
rudi |
}
|
| 354 |
|
|
else {
|
| 355 |
|
|
printf("\t Vecor mismatch between library and system calculations. This Vector\n");
|
| 356 |
|
|
printf("\t will not be placed in to vector file ...\n");
|
| 357 |
|
|
}
|
| 358 |
|
|
|
| 359 |
|
|
}
|
| 360 |
|
|
|
| 361 |
|
|
|
| 362 |
|
|
close(fp);
|
| 363 |
|
|
|
| 364 |
|
|
if(!quiet) {
|
| 365 |
|
|
printf("Found %d errors\n",err_count);
|
| 366 |
|
|
printf("Wrote %d vectors from total %d specified.\n", (count-err_count), count);
|
| 367 |
|
|
|
| 368 |
|
|
printf("\n ... f2i done.\n");
|
| 369 |
|
|
}
|
| 370 |
|
|
return(0);
|
| 371 |
|
|
}
|
| 372 |
|
|
|
| 373 |
|
|
float32 get_fp() {
|
| 374 |
|
|
float32 f1;
|
| 375 |
|
|
int i1, i2, e;
|
| 376 |
|
|
|
| 377 |
|
|
if(large>0) i2 = rand();
|
| 378 |
|
|
else i2 = 0;
|
| 379 |
|
|
|
| 380 |
|
|
if(large>1) i1 = rand() | (i2<<16);
|
| 381 |
|
|
else i1 = rand() | (i2<<10);
|
| 382 |
|
|
|
| 383 |
|
|
i1 = i1 & 0x007fffff;
|
| 384 |
|
|
|
| 385 |
|
|
e = rand();
|
| 386 |
|
|
e = e & 0x0ff;
|
| 387 |
|
|
|
| 388 |
|
|
f1 = (e << 23) + i1;
|
| 389 |
|
|
|
| 390 |
|
|
if( rand() & 0x01) f1 = f1 | 0x80000000;
|
| 391 |
|
|
|
| 392 |
|
|
return(f1);
|
| 393 |
|
|
}
|
| 394 |
|
|
|
| 395 |
|
|
static int p0, p1;
|
| 396 |
|
|
|
| 397 |
|
|
// 0x00800000 Minimum Posetive Number
|
| 398 |
|
|
// 0x7f7fffff Maximum Posetive Number
|
| 399 |
|
|
|
| 400 |
|
|
|
| 401 |
|
|
float32 pat0[] = { 0x00800000, 0x00800001, 0x00800002, 0x00800004,
|
| 402 |
|
|
0x00800008, 0x00880000, 0x00900000, 0x00a00000,
|
| 403 |
|
|
0x00c00000, 0x00880001, 0x00900001, 0x00a00001,
|
| 404 |
|
|
0x00c00001, 0x00880002, 0x00900002, 0x00a00002,
|
| 405 |
|
|
0x00c00002, 0x00880004, 0x00900004, 0x00a00004,
|
| 406 |
|
|
0x00c00004, 0x00800003, 0x00800007, 0x0080000f,
|
| 407 |
|
|
0x00f80000, 0x00f00000, 0x00e00000, 0x00f80001,
|
| 408 |
|
|
0x00f00001, 0x00e00001, 0x00f80003, 0x00f00003,
|
| 409 |
|
|
0x00e00003, 0x00c00003, 0x00f80007, 0x00f00007,
|
| 410 |
|
|
0x00e00007, 0x00c00007, 0x00ffffff, 0x00fffffe,
|
| 411 |
|
|
0x00fffffd, 0x00fffffb, 0x00fffff7, 0x00f7ffff,
|
| 412 |
|
|
0x00efffff, 0x00dfffff, 0x00bfffff, 0x00f7fffe,
|
| 413 |
|
|
0x00effffe, 0x00dffffe, 0x00bffffe, 0x00f7fffd,
|
| 414 |
|
|
0x00effffd, 0x00dffffd, 0x00bffffd, 0x00f7fffb,
|
| 415 |
|
|
0x00effffb, 0x00dffffb, 0x00bffffb, 0x00fffffc,
|
| 416 |
|
|
0x00fffff8, 0x00fffff0, 0x0087ffff, 0x008fffff,
|
| 417 |
|
|
0x009fffff, 0x0087fffe, 0x008ffffe, 0x009ffffe,
|
| 418 |
|
|
0x0087fffc, 0x008ffffc, 0x009ffffc, 0x00bffffc,
|
| 419 |
|
|
0x0087fff8, 0x008ffff8, 0x009ffff8, 0x00bffff8,
|
| 420 |
|
|
0x7f000000, 0x7f000001, 0x7f000002, 0x7f000004,
|
| 421 |
|
|
0x7f000008, 0x7f080000, 0x7f100000, 0x7f200000,
|
| 422 |
|
|
0x7f400000, 0x7f080001, 0x7f100001, 0x7f200001,
|
| 423 |
|
|
0x7f400001, 0x7f080002, 0x7f100002, 0x7f200002,
|
| 424 |
|
|
0x7f400002, 0x7f080004, 0x7f100004, 0x7f200004,
|
| 425 |
|
|
0x7f400004, 0x7f000003, 0x7f000007, 0x7f00000f,
|
| 426 |
|
|
0x7f780000, 0x7f700000, 0x7f600000, 0x7f780001,
|
| 427 |
|
|
0x7f700001, 0x7f600001, 0x7f780003, 0x7f700003,
|
| 428 |
|
|
0x7f600003, 0x7f400003, 0x7f780007, 0x7f700007,
|
| 429 |
|
|
0x7f600007, 0x7f400007, 0x7f7fffff, 0x7f7ffffe,
|
| 430 |
|
|
0x7f7ffffd, 0x7f7ffffb, 0x7f7ffff7, 0x7f77ffff,
|
| 431 |
|
|
0x7f6fffff, 0x7f5fffff, 0x7f3fffff, 0x7f77fffe,
|
| 432 |
|
|
0x7f6ffffe, 0x7f5ffffe, 0x7f3ffffe, 0x7f77fffd,
|
| 433 |
|
|
0x7f6ffffd, 0x7f5ffffd, 0x7f3ffffd, 0x7f77fffb,
|
| 434 |
|
|
0x7f6ffffb, 0x7f5ffffb, 0x7f3ffffb, 0x7f7ffffc,
|
| 435 |
|
|
0x7f7ffff8, 0x7f7ffff0, 0x7f07ffff, 0x7f0fffff,
|
| 436 |
|
|
0x7f1fffff, 0x7f07fffe, 0x7f0ffffe, 0x7f1ffffe,
|
| 437 |
|
|
0x7f07fffc, 0x7f0ffffc, 0x7f1ffffc, 0x7f3ffffc,
|
| 438 |
|
|
0x7f07fff8, 0x7f0ffff8, 0x7f1ffff8, 0x7f3ffff8,
|
| 439 |
|
|
0x80800000, 0x80800001, 0x80800002, 0x80800004,
|
| 440 |
|
|
0x80800008, 0x80880000, 0x80900000, 0x80a00000,
|
| 441 |
|
|
0x80c00000, 0x80880001, 0x80900001, 0x80a00001,
|
| 442 |
|
|
0x80c00001, 0x80880002, 0x80900002, 0x80a00002,
|
| 443 |
|
|
0x80c00002, 0x80880004, 0x80900004, 0x80a00004,
|
| 444 |
|
|
0x80c00004, 0x80800003, 0x80800007, 0x8080000f,
|
| 445 |
|
|
0x80f80000, 0x80f00000, 0x80e00000, 0x80f80001,
|
| 446 |
|
|
0x80f00001, 0x80e00001, 0x80f80003, 0x80f00003,
|
| 447 |
|
|
0x80e00003, 0x80c00003, 0x80f80007, 0x80f00007,
|
| 448 |
|
|
0x80e00007, 0x80c00007, 0x80ffffff, 0x80fffffe,
|
| 449 |
|
|
0x80fffffd, 0x80fffffb, 0x80fffff7, 0x80f7ffff,
|
| 450 |
|
|
0x80efffff, 0x80dfffff, 0x80bfffff, 0x80f7fffe,
|
| 451 |
|
|
0x80effffe, 0x80dffffe, 0x80bffffe, 0x80f7fffd,
|
| 452 |
|
|
0x80effffd, 0x80dffffd, 0x80bffffd, 0x80f7fffb,
|
| 453 |
|
|
0x80effffb, 0x80dffffb, 0x80bffffb, 0x80fffffc,
|
| 454 |
|
|
0x80fffff8, 0x80fffff0, 0x8087ffff, 0x808fffff,
|
| 455 |
|
|
0x809fffff, 0x8087fffe, 0x808ffffe, 0x809ffffe,
|
| 456 |
|
|
0x8087fffc, 0x808ffffc, 0x809ffffc, 0x80bffffc,
|
| 457 |
|
|
0x8087fff8, 0x808ffff8, 0x809ffff8, 0x80bffff8,
|
| 458 |
|
|
0xff000000, 0xff000001, 0xff000002, 0xff000004,
|
| 459 |
|
|
0xff000008, 0xff080000, 0xff100000, 0xff200000,
|
| 460 |
|
|
0xff400000, 0xff080001, 0xff100001, 0xff200001,
|
| 461 |
|
|
0xff400001, 0xff080002, 0xff100002, 0xff200002,
|
| 462 |
|
|
0xff400002, 0xff080004, 0xff100004, 0xff200004,
|
| 463 |
|
|
0xff400004, 0xff000003, 0xff000007, 0xff00000f,
|
| 464 |
|
|
0xff780000, 0xff700000, 0xff600000, 0xff780001,
|
| 465 |
|
|
0xff700001, 0xff600001, 0xff780003, 0xff700003,
|
| 466 |
|
|
0xff600003, 0xff400003, 0xff780007, 0xff700007,
|
| 467 |
|
|
0xff600007, 0xff400007, 0xff7fffff, 0xff7ffffe,
|
| 468 |
|
|
0xff7ffffd, 0xff7ffffb, 0xff7ffff7, 0xff77ffff,
|
| 469 |
|
|
0xff6fffff, 0xff5fffff, 0xff3fffff, 0xff77fffe,
|
| 470 |
|
|
0xff6ffffe, 0xff5ffffe, 0xff3ffffe, 0xff77fffd,
|
| 471 |
|
|
0xff6ffffd, 0xff5ffffd, 0xff3ffffd, 0xff77fffb,
|
| 472 |
|
|
0xff6ffffb, 0xff5ffffb, 0xff3ffffb, 0xff7ffffc,
|
| 473 |
|
|
0xff7ffff8, 0xff7ffff0, 0xff07ffff, 0xff0fffff,
|
| 474 |
|
|
0xff1fffff, 0xff07fffe, 0xff0ffffe, 0xff1ffffe,
|
| 475 |
|
|
0xff07fffc, 0xff0ffffc, 0xff1ffffc, 0xff3ffffc,
|
| 476 |
|
|
0xff07fff8, 0xff0ffff8, 0xff1ffff8, 0xff3ffff8
|
| 477 |
|
|
};
|
| 478 |
|
|
|
| 479 |
|
|
|
| 480 |
|
|
int pat0_cnt = 304;
|
| 481 |
|
|
|
| 482 |
|
|
|
| 483 |
|
|
float32 pat1[] = { 0x6c800000, 0x3a000001, 0x69800002, 0x79800004,
|
| 484 |
|
|
0x37000008, 0x59080000, 0x7d900000, 0x23200000,
|
| 485 |
|
|
0x59c00000, 0x23880001, 0x5e900001, 0x45a00001,
|
| 486 |
|
|
0x1f400001, 0x63080002, 0x29100002, 0x15200002,
|
| 487 |
|
|
0x43c00002, 0x5d880004, 0x29900004, 0x54200004,
|
| 488 |
|
|
0x09400004, 0x28800003, 0x7f800007, 0x0880000f,
|
| 489 |
|
|
0x3cf80000, 0x4af00000, 0x58e00000, 0x61780001,
|
| 490 |
|
|
0x20700001, 0x0fe00001, 0x15780003, 0x73700003,
|
| 491 |
|
|
0x52e00003, 0x7b400003, 0x10780007, 0x7c700007,
|
| 492 |
|
|
0x30e00007, 0x3dc00007, 0x5f7fffff, 0x45fffffe,
|
| 493 |
|
|
0x407ffffd, 0x18fffffb, 0x48fffff7, 0x60f7ffff,
|
| 494 |
|
|
0x27efffff, 0x145fffff, 0x3e3fffff, 0x5277fffe,
|
| 495 |
|
|
0x3ceffffe, 0x73dffffe, 0x233ffffe, 0x67f7fffd,
|
| 496 |
|
|
0x33effffd, 0x4e5ffffd, 0x243ffffd, 0x4f77fffb,
|
| 497 |
|
|
0x6feffffb, 0x31dffffb, 0x673ffffb, 0x207ffffc,
|
| 498 |
|
|
0x07fffff8, 0x3dfffff0, 0x6187ffff, 0x7f8fffff,
|
| 499 |
|
|
0x7f1fffff, 0x1887fffe, 0x170ffffe, 0x011ffffe,
|
| 500 |
|
|
0x3a87fffc, 0x280ffffc, 0x0a9ffffc, 0x753ffffc,
|
| 501 |
|
|
0x4187fff8, 0x7b8ffff8, 0x2c1ffff8, 0x40bffff8,
|
| 502 |
|
|
0x00000000, 0x00000001, 0x00000002, 0x00000004,
|
| 503 |
|
|
0x00000008, 0x00080000, 0x00100000, 0x00200000,
|
| 504 |
|
|
0x00400000, 0x00080001, 0x00100001, 0x00200001,
|
| 505 |
|
|
0x00400001, 0x00080002, 0x00100002, 0x00200002,
|
| 506 |
|
|
0x00400002, 0x00080004, 0x00100004, 0x00200004,
|
| 507 |
|
|
0x00400004, 0x00000003, 0x00000007, 0x0000000f,
|
| 508 |
|
|
0x00780000, 0x00700000, 0x00600000, 0x00780001,
|
| 509 |
|
|
0x00700001, 0x00600001, 0x00780003, 0x00700003,
|
| 510 |
|
|
0x00600003, 0x00400003, 0x00780007, 0x00700007,
|
| 511 |
|
|
0x00600007, 0x00400007, 0x007fffff, 0x007ffffe,
|
| 512 |
|
|
0x007ffffd, 0x007ffffb, 0x007ffff7, 0x0077ffff,
|
| 513 |
|
|
0x006fffff, 0x005fffff, 0x003fffff, 0x0077fffe,
|
| 514 |
|
|
0x006ffffe, 0x005ffffe, 0x003ffffe, 0x0077fffd,
|
| 515 |
|
|
0x006ffffd, 0x005ffffd, 0x003ffffd, 0x0077fffb,
|
| 516 |
|
|
0x006ffffb, 0x005ffffb, 0x003ffffb, 0x007ffffc,
|
| 517 |
|
|
0x007ffff8, 0x007ffff0, 0x0007ffff, 0x000fffff,
|
| 518 |
|
|
0x001fffff, 0x0007fffe, 0x000ffffe, 0x001ffffe,
|
| 519 |
|
|
0x0007fffc, 0x000ffffc, 0x001ffffc, 0x003ffffc,
|
| 520 |
|
|
0x0007fff8, 0x000ffff8, 0x001ffff8, 0x003ffff8,
|
| 521 |
|
|
0xc7800000, 0xc3800001, 0x84000002, 0xf6800004,
|
| 522 |
|
|
0x90000008, 0xca880000, 0xee900000, 0xc8200000,
|
| 523 |
|
|
0xb0c00000, 0xd3080001, 0xa7100001, 0x84a00001,
|
| 524 |
|
|
0xb6400001, 0xbc880002, 0xee100002, 0xc7a00002,
|
| 525 |
|
|
0xbec00002, 0xe4880004, 0x90100004, 0xfea00004,
|
| 526 |
|
|
0x82c00004, 0x9d000003, 0x9b800007, 0xef00000f,
|
| 527 |
|
|
0xe3780000, 0xadf00000, 0x83e00000, 0xe7f80001,
|
| 528 |
|
|
0xf9700001, 0xbae00001, 0x81f80003, 0xbef00003,
|
| 529 |
|
|
0xb8600003, 0x88400003, 0xf7f80007, 0xcbf00007,
|
| 530 |
|
|
0xa3600007, 0xf2400007, 0x9dffffff, 0xfefffffe,
|
| 531 |
|
|
0xa27ffffd, 0x8ffffffb, 0xc07ffff7, 0xc3f7ffff,
|
| 532 |
|
|
0x806fffff, 0xdcdfffff, 0xda3fffff, 0xd3f7fffe,
|
| 533 |
|
|
0x916ffffe, 0xde5ffffe, 0xd2bffffe, 0x9df7fffd,
|
| 534 |
|
|
0x97effffd, 0x9cdffffd, 0xa43ffffd, 0xf377fffb,
|
| 535 |
|
|
0xe0effffb, 0xe9dffffb, 0xb43ffffb, 0x9c7ffffc,
|
| 536 |
|
|
0xaafffff8, 0xcafffff0, 0xa887ffff, 0xf98fffff,
|
| 537 |
|
|
0xda1fffff, 0xff87fffe, 0xff0ffffe, 0xe19ffffe,
|
| 538 |
|
|
0x8287fffc, 0x808ffffc, 0xab1ffffc, 0xddbffffc,
|
| 539 |
|
|
0xd387fff8, 0xe40ffff8, 0x8d1ffff8, 0xefbffff8,
|
| 540 |
|
|
0x80000000, 0x80000001, 0x80000002, 0x80000004,
|
| 541 |
|
|
0x80000008, 0x80080000, 0x80100000, 0x80200000,
|
| 542 |
|
|
0x80400000, 0x80080001, 0x80100001, 0x80200001,
|
| 543 |
|
|
0x80400001, 0x80080002, 0x80100002, 0x80200002,
|
| 544 |
|
|
0x80400002, 0x80080004, 0x80100004, 0x80200004,
|
| 545 |
|
|
0x80400004, 0x80000003, 0x80000007, 0x8000000f,
|
| 546 |
|
|
0x80780000, 0x80700000, 0x80600000, 0x80780001,
|
| 547 |
|
|
0x80700001, 0x80600001, 0x80780003, 0x80700003,
|
| 548 |
|
|
0x80600003, 0x80400003, 0x80780007, 0x80700007,
|
| 549 |
|
|
0x80600007, 0x80400007, 0x807fffff, 0x807ffffe,
|
| 550 |
|
|
0x807ffffd, 0x807ffffb, 0x807ffff7, 0x8077ffff,
|
| 551 |
|
|
0x806fffff, 0x805fffff, 0x803fffff, 0x8077fffe,
|
| 552 |
|
|
0x806ffffe, 0x805ffffe, 0x803ffffe, 0x8077fffd,
|
| 553 |
|
|
0x806ffffd, 0x805ffffd, 0x803ffffd, 0x8077fffb,
|
| 554 |
|
|
0x806ffffb, 0x805ffffb, 0x803ffffb, 0x807ffffc,
|
| 555 |
|
|
0x807ffff8, 0x807ffff0, 0x8007ffff, 0x800fffff,
|
| 556 |
|
|
0x801fffff, 0x8007fffe, 0x800ffffe, 0x801ffffe,
|
| 557 |
|
|
0x8007fffc, 0x800ffffc, 0x801ffffc, 0x803ffffc,
|
| 558 |
|
|
0x8007fff8, 0x800ffff8, 0x801ffff8, 0x803ffff8,
|
| 559 |
|
|
};
|
| 560 |
|
|
|
| 561 |
|
|
|
| 562 |
|
|
int pat1_cnt = 304;
|
| 563 |
|
|
int pat2_cnt = 124;
|
| 564 |
|
|
|
| 565 |
|
|
float32 pat2[] = { 0x00000000,
|
| 566 |
|
|
0x00000001,
|
| 567 |
|
|
0x00000002,
|
| 568 |
|
|
0x00000004,
|
| 569 |
|
|
0x00000008,
|
| 570 |
|
|
0x00000010,
|
| 571 |
|
|
0x00000020,
|
| 572 |
|
|
0x00000040,
|
| 573 |
|
|
0x00000080,
|
| 574 |
|
|
0x00000100,
|
| 575 |
|
|
0x00000200,
|
| 576 |
|
|
0x00000400,
|
| 577 |
|
|
0x00000800,
|
| 578 |
|
|
0x00001000,
|
| 579 |
|
|
0x00002000,
|
| 580 |
|
|
0x00004000,
|
| 581 |
|
|
0x00008000,
|
| 582 |
|
|
0x00010000,
|
| 583 |
|
|
0x00020000,
|
| 584 |
|
|
0x00040000,
|
| 585 |
|
|
0x00080000,
|
| 586 |
|
|
0x00100000,
|
| 587 |
|
|
0x00200000,
|
| 588 |
|
|
0x00400000,
|
| 589 |
|
|
0x00800000,
|
| 590 |
|
|
0x01000000,
|
| 591 |
|
|
0x02000000,
|
| 592 |
|
|
0x04000000,
|
| 593 |
|
|
0x08000000,
|
| 594 |
|
|
0x10000000,
|
| 595 |
|
|
0x20000000,
|
| 596 |
|
|
0x40000000,
|
| 597 |
|
|
0x80000000,
|
| 598 |
|
|
0xC0000000,
|
| 599 |
|
|
0xE0000000,
|
| 600 |
|
|
0xF0000000,
|
| 601 |
|
|
0xF8000000,
|
| 602 |
|
|
0xFC000000,
|
| 603 |
|
|
0xFE000000,
|
| 604 |
|
|
0xFF000000,
|
| 605 |
|
|
0xFF800000,
|
| 606 |
|
|
0xFFC00000,
|
| 607 |
|
|
0xFFE00000,
|
| 608 |
|
|
0xFFF00000,
|
| 609 |
|
|
0xFFF80000,
|
| 610 |
|
|
0xFFFC0000,
|
| 611 |
|
|
0xFFFE0000,
|
| 612 |
|
|
0xFFFF0000,
|
| 613 |
|
|
0xFFFF8000,
|
| 614 |
|
|
0xFFFFC000,
|
| 615 |
|
|
0xFFFFE000,
|
| 616 |
|
|
0xFFFFF000,
|
| 617 |
|
|
0xFFFFF800,
|
| 618 |
|
|
0xFFFFFC00,
|
| 619 |
|
|
0xFFFFFE00,
|
| 620 |
|
|
0xFFFFFF00,
|
| 621 |
|
|
0xFFFFFF80,
|
| 622 |
|
|
0xFFFFFFC0,
|
| 623 |
|
|
0xFFFFFFE0,
|
| 624 |
|
|
0xFFFFFFF0,
|
| 625 |
|
|
0xFFFFFFF8,
|
| 626 |
|
|
0xFFFFFFFC,
|
| 627 |
|
|
0xFFFFFFFE,
|
| 628 |
|
|
0xFFFFFFFF,
|
| 629 |
|
|
0xFFFFFFFD,
|
| 630 |
|
|
0xFFFFFFFB,
|
| 631 |
|
|
0xFFFFFFF7,
|
| 632 |
|
|
0xFFFFFFEF,
|
| 633 |
|
|
0xFFFFFFDF,
|
| 634 |
|
|
0xFFFFFFBF,
|
| 635 |
|
|
0xFFFFFF7F,
|
| 636 |
|
|
0xFFFFFEFF,
|
| 637 |
|
|
0xFFFFFDFF,
|
| 638 |
|
|
0xFFFFFBFF,
|
| 639 |
|
|
0xFFFFF7FF,
|
| 640 |
|
|
0xFFFFEFFF,
|
| 641 |
|
|
0xFFFFDFFF,
|
| 642 |
|
|
0xFFFFBFFF,
|
| 643 |
|
|
0xFFFF7FFF,
|
| 644 |
|
|
0xFFFEFFFF,
|
| 645 |
|
|
0xFFFDFFFF,
|
| 646 |
|
|
0xFFFBFFFF,
|
| 647 |
|
|
0xFFF7FFFF,
|
| 648 |
|
|
0xFFEFFFFF,
|
| 649 |
|
|
0xFFDFFFFF,
|
| 650 |
|
|
0xFFBFFFFF,
|
| 651 |
|
|
0xFF7FFFFF,
|
| 652 |
|
|
0xFEFFFFFF,
|
| 653 |
|
|
0xFDFFFFFF,
|
| 654 |
|
|
0xFBFFFFFF,
|
| 655 |
|
|
0xF7FFFFFF,
|
| 656 |
|
|
0xEFFFFFFF,
|
| 657 |
|
|
0xDFFFFFFF,
|
| 658 |
|
|
0xBFFFFFFF,
|
| 659 |
|
|
0x7FFFFFFF,
|
| 660 |
|
|
0x3FFFFFFF,
|
| 661 |
|
|
0x1FFFFFFF,
|
| 662 |
|
|
0x0FFFFFFF,
|
| 663 |
|
|
0x07FFFFFF,
|
| 664 |
|
|
0x03FFFFFF,
|
| 665 |
|
|
0x01FFFFFF,
|
| 666 |
|
|
0x00FFFFFF,
|
| 667 |
|
|
0x007FFFFF,
|
| 668 |
|
|
0x003FFFFF,
|
| 669 |
|
|
0x001FFFFF,
|
| 670 |
|
|
0x000FFFFF,
|
| 671 |
|
|
0x0007FFFF,
|
| 672 |
|
|
0x0003FFFF,
|
| 673 |
|
|
0x0001FFFF,
|
| 674 |
|
|
0x0000FFFF,
|
| 675 |
|
|
0x00007FFF,
|
| 676 |
|
|
0x00003FFF,
|
| 677 |
|
|
0x00001FFF,
|
| 678 |
|
|
0x00000FFF,
|
| 679 |
|
|
0x000007FF,
|
| 680 |
|
|
0x000003FF,
|
| 681 |
|
|
0x000001FF,
|
| 682 |
|
|
0x000000FF,
|
| 683 |
|
|
0x0000007F,
|
| 684 |
|
|
0x0000003F,
|
| 685 |
|
|
0x0000001F,
|
| 686 |
|
|
0x0000000F,
|
| 687 |
|
|
0x00000007,
|
| 688 |
|
|
0x00000003
|
| 689 |
|
|
};
|
| 690 |
|
|
|
| 691 |
|
|
|
| 692 |
|
|
float32 get_pat(int mode) {
|
| 693 |
|
|
|
| 694 |
|
|
if(mode==0) {
|
| 695 |
|
|
p0 = 0;
|
| 696 |
|
|
p1 = 0;
|
| 697 |
|
|
return(0);
|
| 698 |
|
|
}
|
| 699 |
|
|
else
|
| 700 |
|
|
if(pat==1) return(get_pat0(mode));
|
| 701 |
|
|
else
|
| 702 |
|
|
if(pat==2) return(get_pat1(mode));
|
| 703 |
|
|
else
|
| 704 |
|
|
if(pat==3) return(get_pat2(mode));
|
| 705 |
|
|
|
| 706 |
|
|
else return(0);
|
| 707 |
|
|
|
| 708 |
|
|
}
|
| 709 |
|
|
|
| 710 |
|
|
|
| 711 |
|
|
|
| 712 |
|
|
float32 get_pat0(int mode) {
|
| 713 |
|
|
float32 x;
|
| 714 |
|
|
|
| 715 |
|
|
if(mode==1) {
|
| 716 |
|
|
if(p0==pat0_cnt) p0 = 0;
|
| 717 |
|
|
x = pat0[p0];
|
| 718 |
|
|
p0++;
|
| 719 |
|
|
return(x);
|
| 720 |
|
|
}
|
| 721 |
|
|
|
| 722 |
|
|
if(mode==2) {
|
| 723 |
|
|
x = pat0[p1];
|
| 724 |
|
|
if(p0==(pat0_cnt) ) p1++;
|
| 725 |
|
|
if(p1==pat0_cnt) p1 = 0;
|
| 726 |
|
|
return(x);
|
| 727 |
|
|
}
|
| 728 |
|
|
|
| 729 |
|
|
return(0);
|
| 730 |
|
|
}
|
| 731 |
|
|
|
| 732 |
|
|
|
| 733 |
|
|
|
| 734 |
|
|
float32 get_pat1(int mode) {
|
| 735 |
|
|
float32 x;
|
| 736 |
|
|
|
| 737 |
|
|
if(mode==1) {
|
| 738 |
|
|
if(p0==pat1_cnt) p0 = 0;
|
| 739 |
|
|
x = pat1[p0];
|
| 740 |
|
|
p0++;
|
| 741 |
|
|
return(x);
|
| 742 |
|
|
}
|
| 743 |
|
|
|
| 744 |
|
|
if(mode==2) {
|
| 745 |
|
|
x = pat1[p1];
|
| 746 |
|
|
if(p0==(pat1_cnt) ) p1++;
|
| 747 |
|
|
if(p1==pat1_cnt) p1 = 0;
|
| 748 |
|
|
return(x);
|
| 749 |
|
|
}
|
| 750 |
|
|
|
| 751 |
|
|
return(0);
|
| 752 |
|
|
}
|
| 753 |
|
|
|
| 754 |
|
|
|
| 755 |
|
|
float32 get_pat2(int mode) {
|
| 756 |
|
|
float32 x;
|
| 757 |
|
|
|
| 758 |
|
|
if(mode==1) {
|
| 759 |
|
|
if(p0==pat2_cnt) p0 = 0;
|
| 760 |
|
|
x = pat2[p0];
|
| 761 |
|
|
p0++;
|
| 762 |
|
|
return(x);
|
| 763 |
|
|
}
|
| 764 |
|
|
|
| 765 |
|
|
if(mode==2) {
|
| 766 |
|
|
x = pat2[p1];
|
| 767 |
|
|
if(p0==(pat2_cnt) ) p1++;
|
| 768 |
|
|
if(p1==pat2_cnt) p1 = 0;
|
| 769 |
|
|
return(x);
|
| 770 |
|
|
}
|
| 771 |
|
|
|
| 772 |
|
|
return(0);
|
| 773 |
|
|
}
|
