borderbasix: include/borderbasix/auxfun2.cc Source File

00001 #ifndef ALREADY_auxfun2
00002 #define ALREADY_auxfun2
00003 
00004 template<typename T>
00005 void egal0(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00006 {
00007 }
00008 template<typename T>
00009 void egal1(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00010 {
00011 tabcoeff[0]=p->nf[(*compt)++];
00012 }
00013 template<typename T>
00014 void egal2(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00015 {
00016 tabcoeff[1]=p->nf[(*compt)++];
00017 }
00018 template<typename T>
00019 void egal3(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00020 {
00021 tabcoeff[0]=p->nf[(*compt)++];
00022 tabcoeff[1]=p->nf[(*compt)++];
00023 }
00024 template<typename T>
00025 void egal4(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00026 {
00027 tabcoeff[2]=p->nf[(*compt)++];
00028 }
00029 template<typename T>
00030 void egal5(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00031 {
00032 tabcoeff[0]=p->nf[(*compt)++];
00033 tabcoeff[2]=p->nf[(*compt)++];
00034 }
00035 template<typename T>
00036 void egal6(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00037 {
00038 tabcoeff[1]=p->nf[(*compt)++];
00039 tabcoeff[2]=p->nf[(*compt)++];
00040 }
00041 template<typename T>
00042 void egal7(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00043 {
00044 tabcoeff[0]=p->nf[(*compt)++];
00045 tabcoeff[1]=p->nf[(*compt)++];
00046 tabcoeff[2]=p->nf[(*compt)++];
00047 }
00048 template<typename T>
00049 void egal8(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00050 {
00051 tabcoeff[3]=p->nf[(*compt)++];
00052 }
00053 template<typename T>
00054 void egal9(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00055 {
00056 tabcoeff[0]=p->nf[(*compt)++];
00057 tabcoeff[3]=p->nf[(*compt)++];
00058 }
00059 template<typename T>
00060 void egal10(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00061 {
00062 tabcoeff[1]=p->nf[(*compt)++];
00063 tabcoeff[3]=p->nf[(*compt)++];
00064 }
00065 template<typename T>
00066 void egal11(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00067 {
00068 tabcoeff[0]=p->nf[(*compt)++];
00069 tabcoeff[1]=p->nf[(*compt)++];
00070 tabcoeff[3]=p->nf[(*compt)++];
00071 }
00072 template<typename T>
00073 void egal12(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00074 {
00075 tabcoeff[2]=p->nf[(*compt)++];
00076 tabcoeff[3]=p->nf[(*compt)++];
00077 }
00078 template<typename T>
00079 void egal13(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00080 {
00081 tabcoeff[0]=p->nf[(*compt)++];
00082 tabcoeff[2]=p->nf[(*compt)++];
00083 tabcoeff[3]=p->nf[(*compt)++];
00084 }
00085 template<typename T>
00086 void egal14(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00087 {
00088 tabcoeff[1]=p->nf[(*compt)++];
00089 tabcoeff[2]=p->nf[(*compt)++];
00090 tabcoeff[3]=p->nf[(*compt)++];
00091 }
00092 template<typename T>
00093 void egal15(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00094 {
00095 tabcoeff[0]=p->nf[(*compt)++];
00096 tabcoeff[1]=p->nf[(*compt)++];
00097 tabcoeff[2]=p->nf[(*compt)++];
00098 tabcoeff[3]=p->nf[(*compt)++];
00099 }
00100 template<typename T>
00101 void egal16(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00102 {
00103 tabcoeff[4]=p->nf[(*compt)++];
00104 }
00105 template<typename T>
00106 void egal17(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00107 {
00108 tabcoeff[0]=p->nf[(*compt)++];
00109 tabcoeff[4]=p->nf[(*compt)++];
00110 }
00111 template<typename T>
00112 void egal18(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00113 {
00114 tabcoeff[1]=p->nf[(*compt)++];
00115 tabcoeff[4]=p->nf[(*compt)++];
00116 }
00117 template<typename T>
00118 void egal19(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00119 {
00120 tabcoeff[0]=p->nf[(*compt)++];
00121 tabcoeff[1]=p->nf[(*compt)++];
00122 tabcoeff[4]=p->nf[(*compt)++];
00123 }
00124 template<typename T>
00125 void egal20(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00126 {
00127 tabcoeff[2]=p->nf[(*compt)++];
00128 tabcoeff[4]=p->nf[(*compt)++];
00129 }
00130 template<typename T>
00131 void egal21(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00132 {
00133 tabcoeff[0]=p->nf[(*compt)++];
00134 tabcoeff[2]=p->nf[(*compt)++];
00135 tabcoeff[4]=p->nf[(*compt)++];
00136 }
00137 template<typename T>
00138 void egal22(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00139 {
00140 tabcoeff[1]=p->nf[(*compt)++];
00141 tabcoeff[2]=p->nf[(*compt)++];
00142 tabcoeff[4]=p->nf[(*compt)++];
00143 }
00144 template<typename T>
00145 void egal23(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00146 {
00147 tabcoeff[0]=p->nf[(*compt)++];
00148 tabcoeff[1]=p->nf[(*compt)++];
00149 tabcoeff[2]=p->nf[(*compt)++];
00150 tabcoeff[4]=p->nf[(*compt)++];
00151 }
00152 template<typename T>
00153 void egal24(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00154 {
00155 tabcoeff[3]=p->nf[(*compt)++];
00156 tabcoeff[4]=p->nf[(*compt)++];
00157 }
00158 template<typename T>
00159 void egal25(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00160 {
00161 tabcoeff[0]=p->nf[(*compt)++];
00162 tabcoeff[3]=p->nf[(*compt)++];
00163 tabcoeff[4]=p->nf[(*compt)++];
00164 }
00165 template<typename T>
00166 void egal26(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00167 {
00168 tabcoeff[1]=p->nf[(*compt)++];
00169 tabcoeff[3]=p->nf[(*compt)++];
00170 tabcoeff[4]=p->nf[(*compt)++];
00171 }
00172 template<typename T>
00173 void egal27(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00174 {
00175 tabcoeff[0]=p->nf[(*compt)++];
00176 tabcoeff[1]=p->nf[(*compt)++];
00177 tabcoeff[3]=p->nf[(*compt)++];
00178 tabcoeff[4]=p->nf[(*compt)++];
00179 }
00180 template<typename T>
00181 void egal28(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00182 {
00183 tabcoeff[2]=p->nf[(*compt)++];
00184 tabcoeff[3]=p->nf[(*compt)++];
00185 tabcoeff[4]=p->nf[(*compt)++];
00186 }
00187 template<typename T>
00188 void egal29(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00189 {
00190 tabcoeff[0]=p->nf[(*compt)++];
00191 tabcoeff[2]=p->nf[(*compt)++];
00192 tabcoeff[3]=p->nf[(*compt)++];
00193 tabcoeff[4]=p->nf[(*compt)++];
00194 }
00195 template<typename T>
00196 void egal30(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00197 {
00198 tabcoeff[1]=p->nf[(*compt)++];
00199 tabcoeff[2]=p->nf[(*compt)++];
00200 tabcoeff[3]=p->nf[(*compt)++];
00201 tabcoeff[4]=p->nf[(*compt)++];
00202 }
00203 template<typename T>
00204 void egal31(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00205 {
00206 tabcoeff[0]=p->nf[(*compt)++];
00207 tabcoeff[1]=p->nf[(*compt)++];
00208 tabcoeff[2]=p->nf[(*compt)++];
00209 tabcoeff[3]=p->nf[(*compt)++];
00210 tabcoeff[4]=p->nf[(*compt)++];
00211 }
00212 template<typename T>
00213 void egal32(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00214 {
00215 tabcoeff[5]=p->nf[(*compt)++];
00216 }
00217 template<typename T>
00218 void egal33(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00219 {
00220 tabcoeff[0]=p->nf[(*compt)++];
00221 tabcoeff[5]=p->nf[(*compt)++];
00222 }
00223 template<typename T>
00224 void egal34(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00225 {
00226 tabcoeff[1]=p->nf[(*compt)++];
00227 tabcoeff[5]=p->nf[(*compt)++];
00228 }
00229 template<typename T>
00230 void egal35(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00231 {
00232 tabcoeff[0]=p->nf[(*compt)++];
00233 tabcoeff[1]=p->nf[(*compt)++];
00234 tabcoeff[5]=p->nf[(*compt)++];
00235 }
00236 template<typename T>
00237 void egal36(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00238 {
00239 tabcoeff[2]=p->nf[(*compt)++];
00240 tabcoeff[5]=p->nf[(*compt)++];
00241 }
00242 template<typename T>
00243 void egal37(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00244 {
00245 tabcoeff[0]=p->nf[(*compt)++];
00246 tabcoeff[2]=p->nf[(*compt)++];
00247 tabcoeff[5]=p->nf[(*compt)++];
00248 }
00249 template<typename T>
00250 void egal38(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00251 {
00252 tabcoeff[1]=p->nf[(*compt)++];
00253 tabcoeff[2]=p->nf[(*compt)++];
00254 tabcoeff[5]=p->nf[(*compt)++];
00255 }
00256 template<typename T>
00257 void egal39(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00258 {
00259 tabcoeff[0]=p->nf[(*compt)++];
00260 tabcoeff[1]=p->nf[(*compt)++];
00261 tabcoeff[2]=p->nf[(*compt)++];
00262 tabcoeff[5]=p->nf[(*compt)++];
00263 }
00264 template<typename T>
00265 void egal40(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00266 {
00267 tabcoeff[3]=p->nf[(*compt)++];
00268 tabcoeff[5]=p->nf[(*compt)++];
00269 }
00270 template<typename T>
00271 void egal41(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00272 {
00273 tabcoeff[0]=p->nf[(*compt)++];
00274 tabcoeff[3]=p->nf[(*compt)++];
00275 tabcoeff[5]=p->nf[(*compt)++];
00276 }
00277 template<typename T>
00278 void egal42(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00279 {
00280 tabcoeff[1]=p->nf[(*compt)++];
00281 tabcoeff[3]=p->nf[(*compt)++];
00282 tabcoeff[5]=p->nf[(*compt)++];
00283 }
00284 template<typename T>
00285 void egal43(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00286 {
00287 tabcoeff[0]=p->nf[(*compt)++];
00288 tabcoeff[1]=p->nf[(*compt)++];
00289 tabcoeff[3]=p->nf[(*compt)++];
00290 tabcoeff[5]=p->nf[(*compt)++];
00291 }
00292 template<typename T>
00293 void egal44(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00294 {
00295 tabcoeff[2]=p->nf[(*compt)++];
00296 tabcoeff[3]=p->nf[(*compt)++];
00297 tabcoeff[5]=p->nf[(*compt)++];
00298 }
00299 template<typename T>
00300 void egal45(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00301 {
00302 tabcoeff[0]=p->nf[(*compt)++];
00303 tabcoeff[2]=p->nf[(*compt)++];
00304 tabcoeff[3]=p->nf[(*compt)++];
00305 tabcoeff[5]=p->nf[(*compt)++];
00306 }
00307 template<typename T>
00308 void egal46(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00309 {
00310 tabcoeff[1]=p->nf[(*compt)++];
00311 tabcoeff[2]=p->nf[(*compt)++];
00312 tabcoeff[3]=p->nf[(*compt)++];
00313 tabcoeff[5]=p->nf[(*compt)++];
00314 }
00315 template<typename T>
00316 void egal47(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00317 {
00318 tabcoeff[0]=p->nf[(*compt)++];
00319 tabcoeff[1]=p->nf[(*compt)++];
00320 tabcoeff[2]=p->nf[(*compt)++];
00321 tabcoeff[3]=p->nf[(*compt)++];
00322 tabcoeff[5]=p->nf[(*compt)++];
00323 }
00324 template<typename T>
00325 void egal48(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00326 {
00327 tabcoeff[4]=p->nf[(*compt)++];
00328 tabcoeff[5]=p->nf[(*compt)++];
00329 }
00330 template<typename T>
00331 void egal49(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00332 {
00333 tabcoeff[0]=p->nf[(*compt)++];
00334 tabcoeff[4]=p->nf[(*compt)++];
00335 tabcoeff[5]=p->nf[(*compt)++];
00336 }
00337 template<typename T>
00338 void egal50(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00339 {
00340 tabcoeff[1]=p->nf[(*compt)++];
00341 tabcoeff[4]=p->nf[(*compt)++];
00342 tabcoeff[5]=p->nf[(*compt)++];
00343 }
00344 template<typename T>
00345 void egal51(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00346 {
00347 tabcoeff[0]=p->nf[(*compt)++];
00348 tabcoeff[1]=p->nf[(*compt)++];
00349 tabcoeff[4]=p->nf[(*compt)++];
00350 tabcoeff[5]=p->nf[(*compt)++];
00351 }
00352 template<typename T>
00353 void egal52(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00354 {
00355 tabcoeff[2]=p->nf[(*compt)++];
00356 tabcoeff[4]=p->nf[(*compt)++];
00357 tabcoeff[5]=p->nf[(*compt)++];
00358 }
00359 template<typename T>
00360 void egal53(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00361 {
00362 tabcoeff[0]=p->nf[(*compt)++];
00363 tabcoeff[2]=p->nf[(*compt)++];
00364 tabcoeff[4]=p->nf[(*compt)++];
00365 tabcoeff[5]=p->nf[(*compt)++];
00366 }
00367 template<typename T>
00368 void egal54(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00369 {
00370 tabcoeff[1]=p->nf[(*compt)++];
00371 tabcoeff[2]=p->nf[(*compt)++];
00372 tabcoeff[4]=p->nf[(*compt)++];
00373 tabcoeff[5]=p->nf[(*compt)++];
00374 }
00375 template<typename T>
00376 void egal55(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00377 {
00378 tabcoeff[0]=p->nf[(*compt)++];
00379 tabcoeff[1]=p->nf[(*compt)++];
00380 tabcoeff[2]=p->nf[(*compt)++];
00381 tabcoeff[4]=p->nf[(*compt)++];
00382 tabcoeff[5]=p->nf[(*compt)++];
00383 }
00384 template<typename T>
00385 void egal56(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00386 {
00387 tabcoeff[3]=p->nf[(*compt)++];
00388 tabcoeff[4]=p->nf[(*compt)++];
00389 tabcoeff[5]=p->nf[(*compt)++];
00390 }
00391 template<typename T>
00392 void egal57(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00393 {
00394 tabcoeff[0]=p->nf[(*compt)++];
00395 tabcoeff[3]=p->nf[(*compt)++];
00396 tabcoeff[4]=p->nf[(*compt)++];
00397 tabcoeff[5]=p->nf[(*compt)++];
00398 }
00399 template<typename T>
00400 void egal58(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00401 {
00402 tabcoeff[1]=p->nf[(*compt)++];
00403 tabcoeff[3]=p->nf[(*compt)++];
00404 tabcoeff[4]=p->nf[(*compt)++];
00405 tabcoeff[5]=p->nf[(*compt)++];
00406 }
00407 template<typename T>
00408 void egal59(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00409 {
00410 tabcoeff[0]=p->nf[(*compt)++];
00411 tabcoeff[1]=p->nf[(*compt)++];
00412 tabcoeff[3]=p->nf[(*compt)++];
00413 tabcoeff[4]=p->nf[(*compt)++];
00414 tabcoeff[5]=p->nf[(*compt)++];
00415 }
00416 template<typename T>
00417 void egal60(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00418 {
00419 tabcoeff[2]=p->nf[(*compt)++];
00420 tabcoeff[3]=p->nf[(*compt)++];
00421 tabcoeff[4]=p->nf[(*compt)++];
00422 tabcoeff[5]=p->nf[(*compt)++];
00423 }
00424 template<typename T>
00425 void egal61(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00426 {
00427 tabcoeff[0]=p->nf[(*compt)++];
00428 tabcoeff[2]=p->nf[(*compt)++];
00429 tabcoeff[3]=p->nf[(*compt)++];
00430 tabcoeff[4]=p->nf[(*compt)++];
00431 tabcoeff[5]=p->nf[(*compt)++];
00432 }
00433 template<typename T>
00434 void egal62(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00435 {
00436 tabcoeff[1]=p->nf[(*compt)++];
00437 tabcoeff[2]=p->nf[(*compt)++];
00438 tabcoeff[3]=p->nf[(*compt)++];
00439 tabcoeff[4]=p->nf[(*compt)++];
00440 tabcoeff[5]=p->nf[(*compt)++];
00441 }
00442 template<typename T>
00443 void egal63(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00444 {
00445 tabcoeff[0]=p->nf[(*compt)++];
00446 tabcoeff[1]=p->nf[(*compt)++];
00447 tabcoeff[2]=p->nf[(*compt)++];
00448 tabcoeff[3]=p->nf[(*compt)++];
00449 tabcoeff[4]=p->nf[(*compt)++];
00450 tabcoeff[5]=p->nf[(*compt)++];
00451 }
00452 template<typename T>
00453 void egal64(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00454 {
00455 tabcoeff[6]=p->nf[(*compt)++];
00456 }
00457 template<typename T>
00458 void egal65(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00459 {
00460 tabcoeff[0]=p->nf[(*compt)++];
00461 tabcoeff[6]=p->nf[(*compt)++];
00462 }
00463 template<typename T>
00464 void egal66(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00465 {
00466 tabcoeff[1]=p->nf[(*compt)++];
00467 tabcoeff[6]=p->nf[(*compt)++];
00468 }
00469 template<typename T>
00470 void egal67(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00471 {
00472 tabcoeff[0]=p->nf[(*compt)++];
00473 tabcoeff[1]=p->nf[(*compt)++];
00474 tabcoeff[6]=p->nf[(*compt)++];
00475 }
00476 template<typename T>
00477 void egal68(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00478 {
00479 tabcoeff[2]=p->nf[(*compt)++];
00480 tabcoeff[6]=p->nf[(*compt)++];
00481 }
00482 template<typename T>
00483 void egal69(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00484 {
00485 tabcoeff[0]=p->nf[(*compt)++];
00486 tabcoeff[2]=p->nf[(*compt)++];
00487 tabcoeff[6]=p->nf[(*compt)++];
00488 }
00489 template<typename T>
00490 void egal70(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00491 {
00492 tabcoeff[1]=p->nf[(*compt)++];
00493 tabcoeff[2]=p->nf[(*compt)++];
00494 tabcoeff[6]=p->nf[(*compt)++];
00495 }
00496 template<typename T>
00497 void egal71(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00498 {
00499 tabcoeff[0]=p->nf[(*compt)++];
00500 tabcoeff[1]=p->nf[(*compt)++];
00501 tabcoeff[2]=p->nf[(*compt)++];
00502 tabcoeff[6]=p->nf[(*compt)++];
00503 }
00504 template<typename T>
00505 void egal72(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00506 {
00507 tabcoeff[3]=p->nf[(*compt)++];
00508 tabcoeff[6]=p->nf[(*compt)++];
00509 }
00510 template<typename T>
00511 void egal73(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00512 {
00513 tabcoeff[0]=p->nf[(*compt)++];
00514 tabcoeff[3]=p->nf[(*compt)++];
00515 tabcoeff[6]=p->nf[(*compt)++];
00516 }
00517 template<typename T>
00518 void egal74(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00519 {
00520 tabcoeff[1]=p->nf[(*compt)++];
00521 tabcoeff[3]=p->nf[(*compt)++];
00522 tabcoeff[6]=p->nf[(*compt)++];
00523 }
00524 template<typename T>
00525 void egal75(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00526 {
00527 tabcoeff[0]=p->nf[(*compt)++];
00528 tabcoeff[1]=p->nf[(*compt)++];
00529 tabcoeff[3]=p->nf[(*compt)++];
00530 tabcoeff[6]=p->nf[(*compt)++];
00531 }
00532 template<typename T>
00533 void egal76(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00534 {
00535 tabcoeff[2]=p->nf[(*compt)++];
00536 tabcoeff[3]=p->nf[(*compt)++];
00537 tabcoeff[6]=p->nf[(*compt)++];
00538 }
00539 template<typename T>
00540 void egal77(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00541 {
00542 tabcoeff[0]=p->nf[(*compt)++];
00543 tabcoeff[2]=p->nf[(*compt)++];
00544 tabcoeff[3]=p->nf[(*compt)++];
00545 tabcoeff[6]=p->nf[(*compt)++];
00546 }
00547 template<typename T>
00548 void egal78(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00549 {
00550 tabcoeff[1]=p->nf[(*compt)++];
00551 tabcoeff[2]=p->nf[(*compt)++];
00552 tabcoeff[3]=p->nf[(*compt)++];
00553 tabcoeff[6]=p->nf[(*compt)++];
00554 }
00555 template<typename T>
00556 void egal79(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00557 {
00558 tabcoeff[0]=p->nf[(*compt)++];
00559 tabcoeff[1]=p->nf[(*compt)++];
00560 tabcoeff[2]=p->nf[(*compt)++];
00561 tabcoeff[3]=p->nf[(*compt)++];
00562 tabcoeff[6]=p->nf[(*compt)++];
00563 }
00564 template<typename T>
00565 void egal80(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00566 {
00567 tabcoeff[4]=p->nf[(*compt)++];
00568 tabcoeff[6]=p->nf[(*compt)++];
00569 }
00570 template<typename T>
00571 void egal81(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00572 {
00573 tabcoeff[0]=p->nf[(*compt)++];
00574 tabcoeff[4]=p->nf[(*compt)++];
00575 tabcoeff[6]=p->nf[(*compt)++];
00576 }
00577 template<typename T>
00578 void egal82(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00579 {
00580 tabcoeff[1]=p->nf[(*compt)++];
00581 tabcoeff[4]=p->nf[(*compt)++];
00582 tabcoeff[6]=p->nf[(*compt)++];
00583 }
00584 template<typename T>
00585 void egal83(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00586 {
00587 tabcoeff[0]=p->nf[(*compt)++];
00588 tabcoeff[1]=p->nf[(*compt)++];
00589 tabcoeff[4]=p->nf[(*compt)++];
00590 tabcoeff[6]=p->nf[(*compt)++];
00591 }
00592 template<typename T>
00593 void egal84(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00594 {
00595 tabcoeff[2]=p->nf[(*compt)++];
00596 tabcoeff[4]=p->nf[(*compt)++];
00597 tabcoeff[6]=p->nf[(*compt)++];
00598 }
00599 template<typename T>
00600 void egal85(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00601 {
00602 tabcoeff[0]=p->nf[(*compt)++];
00603 tabcoeff[2]=p->nf[(*compt)++];
00604 tabcoeff[4]=p->nf[(*compt)++];
00605 tabcoeff[6]=p->nf[(*compt)++];
00606 }
00607 template<typename T>
00608 void egal86(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00609 {
00610 tabcoeff[1]=p->nf[(*compt)++];
00611 tabcoeff[2]=p->nf[(*compt)++];
00612 tabcoeff[4]=p->nf[(*compt)++];
00613 tabcoeff[6]=p->nf[(*compt)++];
00614 }
00615 template<typename T>
00616 void egal87(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00617 {
00618 tabcoeff[0]=p->nf[(*compt)++];
00619 tabcoeff[1]=p->nf[(*compt)++];
00620 tabcoeff[2]=p->nf[(*compt)++];
00621 tabcoeff[4]=p->nf[(*compt)++];
00622 tabcoeff[6]=p->nf[(*compt)++];
00623 }
00624 template<typename T>
00625 void egal88(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00626 {
00627 tabcoeff[3]=p->nf[(*compt)++];
00628 tabcoeff[4]=p->nf[(*compt)++];
00629 tabcoeff[6]=p->nf[(*compt)++];
00630 }
00631 template<typename T>
00632 void egal89(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00633 {
00634 tabcoeff[0]=p->nf[(*compt)++];
00635 tabcoeff[3]=p->nf[(*compt)++];
00636 tabcoeff[4]=p->nf[(*compt)++];
00637 tabcoeff[6]=p->nf[(*compt)++];
00638 }
00639 template<typename T>
00640 void egal90(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00641 {
00642 tabcoeff[1]=p->nf[(*compt)++];
00643 tabcoeff[3]=p->nf[(*compt)++];
00644 tabcoeff[4]=p->nf[(*compt)++];
00645 tabcoeff[6]=p->nf[(*compt)++];
00646 }
00647 template<typename T>
00648 void egal91(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00649 {
00650 tabcoeff[0]=p->nf[(*compt)++];
00651 tabcoeff[1]=p->nf[(*compt)++];
00652 tabcoeff[3]=p->nf[(*compt)++];
00653 tabcoeff[4]=p->nf[(*compt)++];
00654 tabcoeff[6]=p->nf[(*compt)++];
00655 }
00656 template<typename T>
00657 void egal92(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00658 {
00659 tabcoeff[2]=p->nf[(*compt)++];
00660 tabcoeff[3]=p->nf[(*compt)++];
00661 tabcoeff[4]=p->nf[(*compt)++];
00662 tabcoeff[6]=p->nf[(*compt)++];
00663 }
00664 template<typename T>
00665 void egal93(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00666 {
00667 tabcoeff[0]=p->nf[(*compt)++];
00668 tabcoeff[2]=p->nf[(*compt)++];
00669 tabcoeff[3]=p->nf[(*compt)++];
00670 tabcoeff[4]=p->nf[(*compt)++];
00671 tabcoeff[6]=p->nf[(*compt)++];
00672 }
00673 template<typename T>
00674 void egal94(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00675 {
00676 tabcoeff[1]=p->nf[(*compt)++];
00677 tabcoeff[2]=p->nf[(*compt)++];
00678 tabcoeff[3]=p->nf[(*compt)++];
00679 tabcoeff[4]=p->nf[(*compt)++];
00680 tabcoeff[6]=p->nf[(*compt)++];
00681 }
00682 template<typename T>
00683 void egal95(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00684 {
00685 tabcoeff[0]=p->nf[(*compt)++];
00686 tabcoeff[1]=p->nf[(*compt)++];
00687 tabcoeff[2]=p->nf[(*compt)++];
00688 tabcoeff[3]=p->nf[(*compt)++];
00689 tabcoeff[4]=p->nf[(*compt)++];
00690 tabcoeff[6]=p->nf[(*compt)++];
00691 }
00692 template<typename T>
00693 void egal96(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00694 {
00695 tabcoeff[5]=p->nf[(*compt)++];
00696 tabcoeff[6]=p->nf[(*compt)++];
00697 }
00698 template<typename T>
00699 void egal97(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00700 {
00701 tabcoeff[0]=p->nf[(*compt)++];
00702 tabcoeff[5]=p->nf[(*compt)++];
00703 tabcoeff[6]=p->nf[(*compt)++];
00704 }
00705 template<typename T>
00706 void egal98(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00707 {
00708 tabcoeff[1]=p->nf[(*compt)++];
00709 tabcoeff[5]=p->nf[(*compt)++];
00710 tabcoeff[6]=p->nf[(*compt)++];
00711 }
00712 template<typename T>
00713 void egal99(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00714 {
00715 tabcoeff[0]=p->nf[(*compt)++];
00716 tabcoeff[1]=p->nf[(*compt)++];
00717 tabcoeff[5]=p->nf[(*compt)++];
00718 tabcoeff[6]=p->nf[(*compt)++];
00719 }
00720 template<typename T>
00721 void egal100(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00722 {
00723 tabcoeff[2]=p->nf[(*compt)++];
00724 tabcoeff[5]=p->nf[(*compt)++];
00725 tabcoeff[6]=p->nf[(*compt)++];
00726 }
00727 template<typename T>
00728 void egal101(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00729 {
00730 tabcoeff[0]=p->nf[(*compt)++];
00731 tabcoeff[2]=p->nf[(*compt)++];
00732 tabcoeff[5]=p->nf[(*compt)++];
00733 tabcoeff[6]=p->nf[(*compt)++];
00734 }
00735 template<typename T>
00736 void egal102(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00737 {
00738 tabcoeff[1]=p->nf[(*compt)++];
00739 tabcoeff[2]=p->nf[(*compt)++];
00740 tabcoeff[5]=p->nf[(*compt)++];
00741 tabcoeff[6]=p->nf[(*compt)++];
00742 }
00743 template<typename T>
00744 void egal103(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00745 {
00746 tabcoeff[0]=p->nf[(*compt)++];
00747 tabcoeff[1]=p->nf[(*compt)++];
00748 tabcoeff[2]=p->nf[(*compt)++];
00749 tabcoeff[5]=p->nf[(*compt)++];
00750 tabcoeff[6]=p->nf[(*compt)++];
00751 }
00752 template<typename T>
00753 void egal104(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00754 {
00755 tabcoeff[3]=p->nf[(*compt)++];
00756 tabcoeff[5]=p->nf[(*compt)++];
00757 tabcoeff[6]=p->nf[(*compt)++];
00758 }
00759 template<typename T>
00760 void egal105(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00761 {
00762 tabcoeff[0]=p->nf[(*compt)++];
00763 tabcoeff[3]=p->nf[(*compt)++];
00764 tabcoeff[5]=p->nf[(*compt)++];
00765 tabcoeff[6]=p->nf[(*compt)++];
00766 }
00767 template<typename T>
00768 void egal106(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00769 {
00770 tabcoeff[1]=p->nf[(*compt)++];
00771 tabcoeff[3]=p->nf[(*compt)++];
00772 tabcoeff[5]=p->nf[(*compt)++];
00773 tabcoeff[6]=p->nf[(*compt)++];
00774 }
00775 template<typename T>
00776 void egal107(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00777 {
00778 tabcoeff[0]=p->nf[(*compt)++];
00779 tabcoeff[1]=p->nf[(*compt)++];
00780 tabcoeff[3]=p->nf[(*compt)++];
00781 tabcoeff[5]=p->nf[(*compt)++];
00782 tabcoeff[6]=p->nf[(*compt)++];
00783 }
00784 template<typename T>
00785 void egal108(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00786 {
00787 tabcoeff[2]=p->nf[(*compt)++];
00788 tabcoeff[3]=p->nf[(*compt)++];
00789 tabcoeff[5]=p->nf[(*compt)++];
00790 tabcoeff[6]=p->nf[(*compt)++];
00791 }
00792 template<typename T>
00793 void egal109(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00794 {
00795 tabcoeff[0]=p->nf[(*compt)++];
00796 tabcoeff[2]=p->nf[(*compt)++];
00797 tabcoeff[3]=p->nf[(*compt)++];
00798 tabcoeff[5]=p->nf[(*compt)++];
00799 tabcoeff[6]=p->nf[(*compt)++];
00800 }
00801 template<typename T>
00802 void egal110(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00803 {
00804 tabcoeff[1]=p->nf[(*compt)++];
00805 tabcoeff[2]=p->nf[(*compt)++];
00806 tabcoeff[3]=p->nf[(*compt)++];
00807 tabcoeff[5]=p->nf[(*compt)++];
00808 tabcoeff[6]=p->nf[(*compt)++];
00809 }
00810 template<typename T>
00811 void egal111(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00812 {
00813 tabcoeff[0]=p->nf[(*compt)++];
00814 tabcoeff[1]=p->nf[(*compt)++];
00815 tabcoeff[2]=p->nf[(*compt)++];
00816 tabcoeff[3]=p->nf[(*compt)++];
00817 tabcoeff[5]=p->nf[(*compt)++];
00818 tabcoeff[6]=p->nf[(*compt)++];
00819 }
00820 template<typename T>
00821 void egal112(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00822 {
00823 tabcoeff[4]=p->nf[(*compt)++];
00824 tabcoeff[5]=p->nf[(*compt)++];
00825 tabcoeff[6]=p->nf[(*compt)++];
00826 }
00827 template<typename T>
00828 void egal113(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00829 {
00830 tabcoeff[0]=p->nf[(*compt)++];
00831 tabcoeff[4]=p->nf[(*compt)++];
00832 tabcoeff[5]=p->nf[(*compt)++];
00833 tabcoeff[6]=p->nf[(*compt)++];
00834 }
00835 template<typename T>
00836 void egal114(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00837 {
00838 tabcoeff[1]=p->nf[(*compt)++];
00839 tabcoeff[4]=p->nf[(*compt)++];
00840 tabcoeff[5]=p->nf[(*compt)++];
00841 tabcoeff[6]=p->nf[(*compt)++];
00842 }
00843 template<typename T>
00844 void egal115(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00845 {
00846 tabcoeff[0]=p->nf[(*compt)++];
00847 tabcoeff[1]=p->nf[(*compt)++];
00848 tabcoeff[4]=p->nf[(*compt)++];
00849 tabcoeff[5]=p->nf[(*compt)++];
00850 tabcoeff[6]=p->nf[(*compt)++];
00851 }
00852 template<typename T>
00853 void egal116(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00854 {
00855 tabcoeff[2]=p->nf[(*compt)++];
00856 tabcoeff[4]=p->nf[(*compt)++];
00857 tabcoeff[5]=p->nf[(*compt)++];
00858 tabcoeff[6]=p->nf[(*compt)++];
00859 }
00860 template<typename T>
00861 void egal117(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00862 {
00863 tabcoeff[0]=p->nf[(*compt)++];
00864 tabcoeff[2]=p->nf[(*compt)++];
00865 tabcoeff[4]=p->nf[(*compt)++];
00866 tabcoeff[5]=p->nf[(*compt)++];
00867 tabcoeff[6]=p->nf[(*compt)++];
00868 }
00869 template<typename T>
00870 void egal118(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00871 {
00872 tabcoeff[1]=p->nf[(*compt)++];
00873 tabcoeff[2]=p->nf[(*compt)++];
00874 tabcoeff[4]=p->nf[(*compt)++];
00875 tabcoeff[5]=p->nf[(*compt)++];
00876 tabcoeff[6]=p->nf[(*compt)++];
00877 }
00878 template<typename T>
00879 void egal119(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00880 {
00881 tabcoeff[0]=p->nf[(*compt)++];
00882 tabcoeff[1]=p->nf[(*compt)++];
00883 tabcoeff[2]=p->nf[(*compt)++];
00884 tabcoeff[4]=p->nf[(*compt)++];
00885 tabcoeff[5]=p->nf[(*compt)++];
00886 tabcoeff[6]=p->nf[(*compt)++];
00887 }
00888 template<typename T>
00889 void egal120(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00890 {
00891 tabcoeff[3]=p->nf[(*compt)++];
00892 tabcoeff[4]=p->nf[(*compt)++];
00893 tabcoeff[5]=p->nf[(*compt)++];
00894 tabcoeff[6]=p->nf[(*compt)++];
00895 }
00896 template<typename T>
00897 void egal121(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00898 {
00899 tabcoeff[0]=p->nf[(*compt)++];
00900 tabcoeff[3]=p->nf[(*compt)++];
00901 tabcoeff[4]=p->nf[(*compt)++];
00902 tabcoeff[5]=p->nf[(*compt)++];
00903 tabcoeff[6]=p->nf[(*compt)++];
00904 }
00905 template<typename T>
00906 void egal122(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00907 {
00908 tabcoeff[1]=p->nf[(*compt)++];
00909 tabcoeff[3]=p->nf[(*compt)++];
00910 tabcoeff[4]=p->nf[(*compt)++];
00911 tabcoeff[5]=p->nf[(*compt)++];
00912 tabcoeff[6]=p->nf[(*compt)++];
00913 }
00914 template<typename T>
00915 void egal123(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00916 {
00917 tabcoeff[0]=p->nf[(*compt)++];
00918 tabcoeff[1]=p->nf[(*compt)++];
00919 tabcoeff[3]=p->nf[(*compt)++];
00920 tabcoeff[4]=p->nf[(*compt)++];
00921 tabcoeff[5]=p->nf[(*compt)++];
00922 tabcoeff[6]=p->nf[(*compt)++];
00923 }
00924 template<typename T>
00925 void egal124(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00926 {
00927 tabcoeff[2]=p->nf[(*compt)++];
00928 tabcoeff[3]=p->nf[(*compt)++];
00929 tabcoeff[4]=p->nf[(*compt)++];
00930 tabcoeff[5]=p->nf[(*compt)++];
00931 tabcoeff[6]=p->nf[(*compt)++];
00932 }
00933 template<typename T>
00934 void egal125(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00935 {
00936 tabcoeff[0]=p->nf[(*compt)++];
00937 tabcoeff[2]=p->nf[(*compt)++];
00938 tabcoeff[3]=p->nf[(*compt)++];
00939 tabcoeff[4]=p->nf[(*compt)++];
00940 tabcoeff[5]=p->nf[(*compt)++];
00941 tabcoeff[6]=p->nf[(*compt)++];
00942 }
00943 template<typename T>
00944 void egal126(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00945 {
00946 tabcoeff[1]=p->nf[(*compt)++];
00947 tabcoeff[2]=p->nf[(*compt)++];
00948 tabcoeff[3]=p->nf[(*compt)++];
00949 tabcoeff[4]=p->nf[(*compt)++];
00950 tabcoeff[5]=p->nf[(*compt)++];
00951 tabcoeff[6]=p->nf[(*compt)++];
00952 }
00953 template<typename T>
00954 void egal127(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00955 {
00956 tabcoeff[0]=p->nf[(*compt)++];
00957 tabcoeff[1]=p->nf[(*compt)++];
00958 tabcoeff[2]=p->nf[(*compt)++];
00959 tabcoeff[3]=p->nf[(*compt)++];
00960 tabcoeff[4]=p->nf[(*compt)++];
00961 tabcoeff[5]=p->nf[(*compt)++];
00962 tabcoeff[6]=p->nf[(*compt)++];
00963 }
00964 template<typename T>
00965 void egal128(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00966 {
00967 tabcoeff[7]=p->nf[(*compt)++];
00968 }
00969 template<typename T>
00970 void egal129(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00971 {
00972 tabcoeff[0]=p->nf[(*compt)++];
00973 tabcoeff[7]=p->nf[(*compt)++];
00974 }
00975 template<typename T>
00976 void egal130(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00977 {
00978 tabcoeff[1]=p->nf[(*compt)++];
00979 tabcoeff[7]=p->nf[(*compt)++];
00980 }
00981 template<typename T>
00982 void egal131(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00983 {
00984 tabcoeff[0]=p->nf[(*compt)++];
00985 tabcoeff[1]=p->nf[(*compt)++];
00986 tabcoeff[7]=p->nf[(*compt)++];
00987 }
00988 template<typename T>
00989 void egal132(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00990 {
00991 tabcoeff[2]=p->nf[(*compt)++];
00992 tabcoeff[7]=p->nf[(*compt)++];
00993 }
00994 template<typename T>
00995 void egal133(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
00996 {
00997 tabcoeff[0]=p->nf[(*compt)++];
00998 tabcoeff[2]=p->nf[(*compt)++];
00999 tabcoeff[7]=p->nf[(*compt)++];
01000 }
01001 template<typename T>
01002 void egal134(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01003 {
01004 tabcoeff[1]=p->nf[(*compt)++];
01005 tabcoeff[2]=p->nf[(*compt)++];
01006 tabcoeff[7]=p->nf[(*compt)++];
01007 }
01008 template<typename T>
01009 void egal135(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01010 {
01011 tabcoeff[0]=p->nf[(*compt)++];
01012 tabcoeff[1]=p->nf[(*compt)++];
01013 tabcoeff[2]=p->nf[(*compt)++];
01014 tabcoeff[7]=p->nf[(*compt)++];
01015 }
01016 template<typename T>
01017 void egal136(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01018 {
01019 tabcoeff[3]=p->nf[(*compt)++];
01020 tabcoeff[7]=p->nf[(*compt)++];
01021 }
01022 template<typename T>
01023 void egal137(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01024 {
01025 tabcoeff[0]=p->nf[(*compt)++];
01026 tabcoeff[3]=p->nf[(*compt)++];
01027 tabcoeff[7]=p->nf[(*compt)++];
01028 }
01029 template<typename T>
01030 void egal138(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01031 {
01032 tabcoeff[1]=p->nf[(*compt)++];
01033 tabcoeff[3]=p->nf[(*compt)++];
01034 tabcoeff[7]=p->nf[(*compt)++];
01035 }
01036 template<typename T>
01037 void egal139(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01038 {
01039 tabcoeff[0]=p->nf[(*compt)++];
01040 tabcoeff[1]=p->nf[(*compt)++];
01041 tabcoeff[3]=p->nf[(*compt)++];
01042 tabcoeff[7]=p->nf[(*compt)++];
01043 }
01044 template<typename T>
01045 void egal140(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01046 {
01047 tabcoeff[2]=p->nf[(*compt)++];
01048 tabcoeff[3]=p->nf[(*compt)++];
01049 tabcoeff[7]=p->nf[(*compt)++];
01050 }
01051 template<typename T>
01052 void egal141(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01053 {
01054 tabcoeff[0]=p->nf[(*compt)++];
01055 tabcoeff[2]=p->nf[(*compt)++];
01056 tabcoeff[3]=p->nf[(*compt)++];
01057 tabcoeff[7]=p->nf[(*compt)++];
01058 }
01059 template<typename T>
01060 void egal142(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01061 {
01062 tabcoeff[1]=p->nf[(*compt)++];
01063 tabcoeff[2]=p->nf[(*compt)++];
01064 tabcoeff[3]=p->nf[(*compt)++];
01065 tabcoeff[7]=p->nf[(*compt)++];
01066 }
01067 template<typename T>
01068 void egal143(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01069 {
01070 tabcoeff[0]=p->nf[(*compt)++];
01071 tabcoeff[1]=p->nf[(*compt)++];
01072 tabcoeff[2]=p->nf[(*compt)++];
01073 tabcoeff[3]=p->nf[(*compt)++];
01074 tabcoeff[7]=p->nf[(*compt)++];
01075 }
01076 template<typename T>
01077 void egal144(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01078 {
01079 tabcoeff[4]=p->nf[(*compt)++];
01080 tabcoeff[7]=p->nf[(*compt)++];
01081 }
01082 template<typename T>
01083 void egal145(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01084 {
01085 tabcoeff[0]=p->nf[(*compt)++];
01086 tabcoeff[4]=p->nf[(*compt)++];
01087 tabcoeff[7]=p->nf[(*compt)++];
01088 }
01089 template<typename T>
01090 void egal146(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01091 {
01092 tabcoeff[1]=p->nf[(*compt)++];
01093 tabcoeff[4]=p->nf[(*compt)++];
01094 tabcoeff[7]=p->nf[(*compt)++];
01095 }
01096 template<typename T>
01097 void egal147(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01098 {
01099 tabcoeff[0]=p->nf[(*compt)++];
01100 tabcoeff[1]=p->nf[(*compt)++];
01101 tabcoeff[4]=p->nf[(*compt)++];
01102 tabcoeff[7]=p->nf[(*compt)++];
01103 }
01104 template<typename T>
01105 void egal148(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01106 {
01107 tabcoeff[2]=p->nf[(*compt)++];
01108 tabcoeff[4]=p->nf[(*compt)++];
01109 tabcoeff[7]=p->nf[(*compt)++];
01110 }
01111 template<typename T>
01112 void egal149(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01113 {
01114 tabcoeff[0]=p->nf[(*compt)++];
01115 tabcoeff[2]=p->nf[(*compt)++];
01116 tabcoeff[4]=p->nf[(*compt)++];
01117 tabcoeff[7]=p->nf[(*compt)++];
01118 }
01119 template<typename T>
01120 void egal150(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01121 {
01122 tabcoeff[1]=p->nf[(*compt)++];
01123 tabcoeff[2]=p->nf[(*compt)++];
01124 tabcoeff[4]=p->nf[(*compt)++];
01125 tabcoeff[7]=p->nf[(*compt)++];
01126 }
01127 template<typename T>
01128 void egal151(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01129 {
01130 tabcoeff[0]=p->nf[(*compt)++];
01131 tabcoeff[1]=p->nf[(*compt)++];
01132 tabcoeff[2]=p->nf[(*compt)++];
01133 tabcoeff[4]=p->nf[(*compt)++];
01134 tabcoeff[7]=p->nf[(*compt)++];
01135 }
01136 template<typename T>
01137 void egal152(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01138 {
01139 tabcoeff[3]=p->nf[(*compt)++];
01140 tabcoeff[4]=p->nf[(*compt)++];
01141 tabcoeff[7]=p->nf[(*compt)++];
01142 }
01143 template<typename T>
01144 void egal153(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01145 {
01146 tabcoeff[0]=p->nf[(*compt)++];
01147 tabcoeff[3]=p->nf[(*compt)++];
01148 tabcoeff[4]=p->nf[(*compt)++];
01149 tabcoeff[7]=p->nf[(*compt)++];
01150 }
01151 template<typename T>
01152 void egal154(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01153 {
01154 tabcoeff[1]=p->nf[(*compt)++];
01155 tabcoeff[3]=p->nf[(*compt)++];
01156 tabcoeff[4]=p->nf[(*compt)++];
01157 tabcoeff[7]=p->nf[(*compt)++];
01158 }
01159 template<typename T>
01160 void egal155(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01161 {
01162 tabcoeff[0]=p->nf[(*compt)++];
01163 tabcoeff[1]=p->nf[(*compt)++];
01164 tabcoeff[3]=p->nf[(*compt)++];
01165 tabcoeff[4]=p->nf[(*compt)++];
01166 tabcoeff[7]=p->nf[(*compt)++];
01167 }
01168 template<typename T>
01169 void egal156(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01170 {
01171 tabcoeff[2]=p->nf[(*compt)++];
01172 tabcoeff[3]=p->nf[(*compt)++];
01173 tabcoeff[4]=p->nf[(*compt)++];
01174 tabcoeff[7]=p->nf[(*compt)++];
01175 }
01176 template<typename T>
01177 void egal157(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01178 {
01179 tabcoeff[0]=p->nf[(*compt)++];
01180 tabcoeff[2]=p->nf[(*compt)++];
01181 tabcoeff[3]=p->nf[(*compt)++];
01182 tabcoeff[4]=p->nf[(*compt)++];
01183 tabcoeff[7]=p->nf[(*compt)++];
01184 }
01185 template<typename T>
01186 void egal158(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01187 {
01188 tabcoeff[1]=p->nf[(*compt)++];
01189 tabcoeff[2]=p->nf[(*compt)++];
01190 tabcoeff[3]=p->nf[(*compt)++];
01191 tabcoeff[4]=p->nf[(*compt)++];
01192 tabcoeff[7]=p->nf[(*compt)++];
01193 }
01194 template<typename T>
01195 void egal159(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01196 {
01197 tabcoeff[0]=p->nf[(*compt)++];
01198 tabcoeff[1]=p->nf[(*compt)++];
01199 tabcoeff[2]=p->nf[(*compt)++];
01200 tabcoeff[3]=p->nf[(*compt)++];
01201 tabcoeff[4]=p->nf[(*compt)++];
01202 tabcoeff[7]=p->nf[(*compt)++];
01203 }
01204 template<typename T>
01205 void egal160(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01206 {
01207 tabcoeff[5]=p->nf[(*compt)++];
01208 tabcoeff[7]=p->nf[(*compt)++];
01209 }
01210 template<typename T>
01211 void egal161(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01212 {
01213 tabcoeff[0]=p->nf[(*compt)++];
01214 tabcoeff[5]=p->nf[(*compt)++];
01215 tabcoeff[7]=p->nf[(*compt)++];
01216 }
01217 template<typename T>
01218 void egal162(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01219 {
01220 tabcoeff[1]=p->nf[(*compt)++];
01221 tabcoeff[5]=p->nf[(*compt)++];
01222 tabcoeff[7]=p->nf[(*compt)++];
01223 }
01224 template<typename T>
01225 void egal163(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01226 {
01227 tabcoeff[0]=p->nf[(*compt)++];
01228 tabcoeff[1]=p->nf[(*compt)++];
01229 tabcoeff[5]=p->nf[(*compt)++];
01230 tabcoeff[7]=p->nf[(*compt)++];
01231 }
01232 template<typename T>
01233 void egal164(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01234 {
01235 tabcoeff[2]=p->nf[(*compt)++];
01236 tabcoeff[5]=p->nf[(*compt)++];
01237 tabcoeff[7]=p->nf[(*compt)++];
01238 }
01239 template<typename T>
01240 void egal165(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01241 {
01242 tabcoeff[0]=p->nf[(*compt)++];
01243 tabcoeff[2]=p->nf[(*compt)++];
01244 tabcoeff[5]=p->nf[(*compt)++];
01245 tabcoeff[7]=p->nf[(*compt)++];
01246 }
01247 template<typename T>
01248 void egal166(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01249 {
01250 tabcoeff[1]=p->nf[(*compt)++];
01251 tabcoeff[2]=p->nf[(*compt)++];
01252 tabcoeff[5]=p->nf[(*compt)++];
01253 tabcoeff[7]=p->nf[(*compt)++];
01254 }
01255 template<typename T>
01256 void egal167(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01257 {
01258 tabcoeff[0]=p->nf[(*compt)++];
01259 tabcoeff[1]=p->nf[(*compt)++];
01260 tabcoeff[2]=p->nf[(*compt)++];
01261 tabcoeff[5]=p->nf[(*compt)++];
01262 tabcoeff[7]=p->nf[(*compt)++];
01263 }
01264 template<typename T>
01265 void egal168(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01266 {
01267 tabcoeff[3]=p->nf[(*compt)++];
01268 tabcoeff[5]=p->nf[(*compt)++];
01269 tabcoeff[7]=p->nf[(*compt)++];
01270 }
01271 template<typename T>
01272 void egal169(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01273 {
01274 tabcoeff[0]=p->nf[(*compt)++];
01275 tabcoeff[3]=p->nf[(*compt)++];
01276 tabcoeff[5]=p->nf[(*compt)++];
01277 tabcoeff[7]=p->nf[(*compt)++];
01278 }
01279 template<typename T>
01280 void egal170(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01281 {
01282 tabcoeff[1]=p->nf[(*compt)++];
01283 tabcoeff[3]=p->nf[(*compt)++];
01284 tabcoeff[5]=p->nf[(*compt)++];
01285 tabcoeff[7]=p->nf[(*compt)++];
01286 }
01287 template<typename T>
01288 void egal171(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01289 {
01290 tabcoeff[0]=p->nf[(*compt)++];
01291 tabcoeff[1]=p->nf[(*compt)++];
01292 tabcoeff[3]=p->nf[(*compt)++];
01293 tabcoeff[5]=p->nf[(*compt)++];
01294 tabcoeff[7]=p->nf[(*compt)++];
01295 }
01296 template<typename T>
01297 void egal172(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01298 {
01299 tabcoeff[2]=p->nf[(*compt)++];
01300 tabcoeff[3]=p->nf[(*compt)++];
01301 tabcoeff[5]=p->nf[(*compt)++];
01302 tabcoeff[7]=p->nf[(*compt)++];
01303 }
01304 template<typename T>
01305 void egal173(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01306 {
01307 tabcoeff[0]=p->nf[(*compt)++];
01308 tabcoeff[2]=p->nf[(*compt)++];
01309 tabcoeff[3]=p->nf[(*compt)++];
01310 tabcoeff[5]=p->nf[(*compt)++];
01311 tabcoeff[7]=p->nf[(*compt)++];
01312 }
01313 template<typename T>
01314 void egal174(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01315 {
01316 tabcoeff[1]=p->nf[(*compt)++];
01317 tabcoeff[2]=p->nf[(*compt)++];
01318 tabcoeff[3]=p->nf[(*compt)++];
01319 tabcoeff[5]=p->nf[(*compt)++];
01320 tabcoeff[7]=p->nf[(*compt)++];
01321 }
01322 template<typename T>
01323 void egal175(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01324 {
01325 tabcoeff[0]=p->nf[(*compt)++];
01326 tabcoeff[1]=p->nf[(*compt)++];
01327 tabcoeff[2]=p->nf[(*compt)++];
01328 tabcoeff[3]=p->nf[(*compt)++];
01329 tabcoeff[5]=p->nf[(*compt)++];
01330 tabcoeff[7]=p->nf[(*compt)++];
01331 }
01332 template<typename T>
01333 void egal176(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01334 {
01335 tabcoeff[4]=p->nf[(*compt)++];
01336 tabcoeff[5]=p->nf[(*compt)++];
01337 tabcoeff[7]=p->nf[(*compt)++];
01338 }
01339 template<typename T>
01340 void egal177(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01341 {
01342 tabcoeff[0]=p->nf[(*compt)++];
01343 tabcoeff[4]=p->nf[(*compt)++];
01344 tabcoeff[5]=p->nf[(*compt)++];
01345 tabcoeff[7]=p->nf[(*compt)++];
01346 }
01347 template<typename T>
01348 void egal178(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01349 {
01350 tabcoeff[1]=p->nf[(*compt)++];
01351 tabcoeff[4]=p->nf[(*compt)++];
01352 tabcoeff[5]=p->nf[(*compt)++];
01353 tabcoeff[7]=p->nf[(*compt)++];
01354 }
01355 template<typename T>
01356 void egal179(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01357 {
01358 tabcoeff[0]=p->nf[(*compt)++];
01359 tabcoeff[1]=p->nf[(*compt)++];
01360 tabcoeff[4]=p->nf[(*compt)++];
01361 tabcoeff[5]=p->nf[(*compt)++];
01362 tabcoeff[7]=p->nf[(*compt)++];
01363 }
01364 template<typename T>
01365 void egal180(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01366 {
01367 tabcoeff[2]=p->nf[(*compt)++];
01368 tabcoeff[4]=p->nf[(*compt)++];
01369 tabcoeff[5]=p->nf[(*compt)++];
01370 tabcoeff[7]=p->nf[(*compt)++];
01371 }
01372 template<typename T>
01373 void egal181(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01374 {
01375 tabcoeff[0]=p->nf[(*compt)++];
01376 tabcoeff[2]=p->nf[(*compt)++];
01377 tabcoeff[4]=p->nf[(*compt)++];
01378 tabcoeff[5]=p->nf[(*compt)++];
01379 tabcoeff[7]=p->nf[(*compt)++];
01380 }
01381 template<typename T>
01382 void egal182(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01383 {
01384 tabcoeff[1]=p->nf[(*compt)++];
01385 tabcoeff[2]=p->nf[(*compt)++];
01386 tabcoeff[4]=p->nf[(*compt)++];
01387 tabcoeff[5]=p->nf[(*compt)++];
01388 tabcoeff[7]=p->nf[(*compt)++];
01389 }
01390 template<typename T>
01391 void egal183(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01392 {
01393 tabcoeff[0]=p->nf[(*compt)++];
01394 tabcoeff[1]=p->nf[(*compt)++];
01395 tabcoeff[2]=p->nf[(*compt)++];
01396 tabcoeff[4]=p->nf[(*compt)++];
01397 tabcoeff[5]=p->nf[(*compt)++];
01398 tabcoeff[7]=p->nf[(*compt)++];
01399 }
01400 template<typename T>
01401 void egal184(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01402 {
01403 tabcoeff[3]=p->nf[(*compt)++];
01404 tabcoeff[4]=p->nf[(*compt)++];
01405 tabcoeff[5]=p->nf[(*compt)++];
01406 tabcoeff[7]=p->nf[(*compt)++];
01407 }
01408 template<typename T>
01409 void egal185(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01410 {
01411 tabcoeff[0]=p->nf[(*compt)++];
01412 tabcoeff[3]=p->nf[(*compt)++];
01413 tabcoeff[4]=p->nf[(*compt)++];
01414 tabcoeff[5]=p->nf[(*compt)++];
01415 tabcoeff[7]=p->nf[(*compt)++];
01416 }
01417 template<typename T>
01418 void egal186(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01419 {
01420 tabcoeff[1]=p->nf[(*compt)++];
01421 tabcoeff[3]=p->nf[(*compt)++];
01422 tabcoeff[4]=p->nf[(*compt)++];
01423 tabcoeff[5]=p->nf[(*compt)++];
01424 tabcoeff[7]=p->nf[(*compt)++];
01425 }
01426 template<typename T>
01427 void egal187(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01428 {
01429 tabcoeff[0]=p->nf[(*compt)++];
01430 tabcoeff[1]=p->nf[(*compt)++];
01431 tabcoeff[3]=p->nf[(*compt)++];
01432 tabcoeff[4]=p->nf[(*compt)++];
01433 tabcoeff[5]=p->nf[(*compt)++];
01434 tabcoeff[7]=p->nf[(*compt)++];
01435 }
01436 template<typename T>
01437 void egal188(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01438 {
01439 tabcoeff[2]=p->nf[(*compt)++];
01440 tabcoeff[3]=p->nf[(*compt)++];
01441 tabcoeff[4]=p->nf[(*compt)++];
01442 tabcoeff[5]=p->nf[(*compt)++];
01443 tabcoeff[7]=p->nf[(*compt)++];
01444 }
01445 template<typename T>
01446 void egal189(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01447 {
01448 tabcoeff[0]=p->nf[(*compt)++];
01449 tabcoeff[2]=p->nf[(*compt)++];
01450 tabcoeff[3]=p->nf[(*compt)++];
01451 tabcoeff[4]=p->nf[(*compt)++];
01452 tabcoeff[5]=p->nf[(*compt)++];
01453 tabcoeff[7]=p->nf[(*compt)++];
01454 }
01455 template<typename T>
01456 void egal190(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01457 {
01458 tabcoeff[1]=p->nf[(*compt)++];
01459 tabcoeff[2]=p->nf[(*compt)++];
01460 tabcoeff[3]=p->nf[(*compt)++];
01461 tabcoeff[4]=p->nf[(*compt)++];
01462 tabcoeff[5]=p->nf[(*compt)++];
01463 tabcoeff[7]=p->nf[(*compt)++];
01464 }
01465 template<typename T>
01466 void egal191(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01467 {
01468 tabcoeff[0]=p->nf[(*compt)++];
01469 tabcoeff[1]=p->nf[(*compt)++];
01470 tabcoeff[2]=p->nf[(*compt)++];
01471 tabcoeff[3]=p->nf[(*compt)++];
01472 tabcoeff[4]=p->nf[(*compt)++];
01473 tabcoeff[5]=p->nf[(*compt)++];
01474 tabcoeff[7]=p->nf[(*compt)++];
01475 }
01476 template<typename T>
01477 void egal192(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01478 {
01479 tabcoeff[6]=p->nf[(*compt)++];
01480 tabcoeff[7]=p->nf[(*compt)++];
01481 }
01482 template<typename T>
01483 void egal193(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01484 {
01485 tabcoeff[0]=p->nf[(*compt)++];
01486 tabcoeff[6]=p->nf[(*compt)++];
01487 tabcoeff[7]=p->nf[(*compt)++];
01488 }
01489 template<typename T>
01490 void egal194(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01491 {
01492 tabcoeff[1]=p->nf[(*compt)++];
01493 tabcoeff[6]=p->nf[(*compt)++];
01494 tabcoeff[7]=p->nf[(*compt)++];
01495 }
01496 template<typename T>
01497 void egal195(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01498 {
01499 tabcoeff[0]=p->nf[(*compt)++];
01500 tabcoeff[1]=p->nf[(*compt)++];
01501 tabcoeff[6]=p->nf[(*compt)++];
01502 tabcoeff[7]=p->nf[(*compt)++];
01503 }
01504 template<typename T>
01505 void egal196(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01506 {
01507 tabcoeff[2]=p->nf[(*compt)++];
01508 tabcoeff[6]=p->nf[(*compt)++];
01509 tabcoeff[7]=p->nf[(*compt)++];
01510 }
01511 template<typename T>
01512 void egal197(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01513 {
01514 tabcoeff[0]=p->nf[(*compt)++];
01515 tabcoeff[2]=p->nf[(*compt)++];
01516 tabcoeff[6]=p->nf[(*compt)++];
01517 tabcoeff[7]=p->nf[(*compt)++];
01518 }
01519 template<typename T>
01520 void egal198(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01521 {
01522 tabcoeff[1]=p->nf[(*compt)++];
01523 tabcoeff[2]=p->nf[(*compt)++];
01524 tabcoeff[6]=p->nf[(*compt)++];
01525 tabcoeff[7]=p->nf[(*compt)++];
01526 }
01527 template<typename T>
01528 void egal199(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01529 {
01530 tabcoeff[0]=p->nf[(*compt)++];
01531 tabcoeff[1]=p->nf[(*compt)++];
01532 tabcoeff[2]=p->nf[(*compt)++];
01533 tabcoeff[6]=p->nf[(*compt)++];
01534 tabcoeff[7]=p->nf[(*compt)++];
01535 }
01536 template<typename T>
01537 void egal200(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01538 {
01539 tabcoeff[3]=p->nf[(*compt)++];
01540 tabcoeff[6]=p->nf[(*compt)++];
01541 tabcoeff[7]=p->nf[(*compt)++];
01542 }
01543 template<typename T>
01544 void egal201(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01545 {
01546 tabcoeff[0]=p->nf[(*compt)++];
01547 tabcoeff[3]=p->nf[(*compt)++];
01548 tabcoeff[6]=p->nf[(*compt)++];
01549 tabcoeff[7]=p->nf[(*compt)++];
01550 }
01551 template<typename T>
01552 void egal202(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01553 {
01554 tabcoeff[1]=p->nf[(*compt)++];
01555 tabcoeff[3]=p->nf[(*compt)++];
01556 tabcoeff[6]=p->nf[(*compt)++];
01557 tabcoeff[7]=p->nf[(*compt)++];
01558 }
01559 template<typename T>
01560 void egal203(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01561 {
01562 tabcoeff[0]=p->nf[(*compt)++];
01563 tabcoeff[1]=p->nf[(*compt)++];
01564 tabcoeff[3]=p->nf[(*compt)++];
01565 tabcoeff[6]=p->nf[(*compt)++];
01566 tabcoeff[7]=p->nf[(*compt)++];
01567 }
01568 template<typename T>
01569 void egal204(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01570 {
01571 tabcoeff[2]=p->nf[(*compt)++];
01572 tabcoeff[3]=p->nf[(*compt)++];
01573 tabcoeff[6]=p->nf[(*compt)++];
01574 tabcoeff[7]=p->nf[(*compt)++];
01575 }
01576 template<typename T>
01577 void egal205(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01578 {
01579 tabcoeff[0]=p->nf[(*compt)++];
01580 tabcoeff[2]=p->nf[(*compt)++];
01581 tabcoeff[3]=p->nf[(*compt)++];
01582 tabcoeff[6]=p->nf[(*compt)++];
01583 tabcoeff[7]=p->nf[(*compt)++];
01584 }
01585 template<typename T>
01586 void egal206(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01587 {
01588 tabcoeff[1]=p->nf[(*compt)++];
01589 tabcoeff[2]=p->nf[(*compt)++];
01590 tabcoeff[3]=p->nf[(*compt)++];
01591 tabcoeff[6]=p->nf[(*compt)++];
01592 tabcoeff[7]=p->nf[(*compt)++];
01593 }
01594 template<typename T>
01595 void egal207(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01596 {
01597 tabcoeff[0]=p->nf[(*compt)++];
01598 tabcoeff[1]=p->nf[(*compt)++];
01599 tabcoeff[2]=p->nf[(*compt)++];
01600 tabcoeff[3]=p->nf[(*compt)++];
01601 tabcoeff[6]=p->nf[(*compt)++];
01602 tabcoeff[7]=p->nf[(*compt)++];
01603 }
01604 template<typename T>
01605 void egal208(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01606 {
01607 tabcoeff[4]=p->nf[(*compt)++];
01608 tabcoeff[6]=p->nf[(*compt)++];
01609 tabcoeff[7]=p->nf[(*compt)++];
01610 }
01611 template<typename T>
01612 void egal209(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01613 {
01614 tabcoeff[0]=p->nf[(*compt)++];
01615 tabcoeff[4]=p->nf[(*compt)++];
01616 tabcoeff[6]=p->nf[(*compt)++];
01617 tabcoeff[7]=p->nf[(*compt)++];
01618 }
01619 template<typename T>
01620 void egal210(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01621 {
01622 tabcoeff[1]=p->nf[(*compt)++];
01623 tabcoeff[4]=p->nf[(*compt)++];
01624 tabcoeff[6]=p->nf[(*compt)++];
01625 tabcoeff[7]=p->nf[(*compt)++];
01626 }
01627 template<typename T>
01628 void egal211(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01629 {
01630 tabcoeff[0]=p->nf[(*compt)++];
01631 tabcoeff[1]=p->nf[(*compt)++];
01632 tabcoeff[4]=p->nf[(*compt)++];
01633 tabcoeff[6]=p->nf[(*compt)++];
01634 tabcoeff[7]=p->nf[(*compt)++];
01635 }
01636 template<typename T>
01637 void egal212(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01638 {
01639 tabcoeff[2]=p->nf[(*compt)++];
01640 tabcoeff[4]=p->nf[(*compt)++];
01641 tabcoeff[6]=p->nf[(*compt)++];
01642 tabcoeff[7]=p->nf[(*compt)++];
01643 }
01644 template<typename T>
01645 void egal213(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01646 {
01647 tabcoeff[0]=p->nf[(*compt)++];
01648 tabcoeff[2]=p->nf[(*compt)++];
01649 tabcoeff[4]=p->nf[(*compt)++];
01650 tabcoeff[6]=p->nf[(*compt)++];
01651 tabcoeff[7]=p->nf[(*compt)++];
01652 }
01653 template<typename T>
01654 void egal214(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01655 {
01656 tabcoeff[1]=p->nf[(*compt)++];
01657 tabcoeff[2]=p->nf[(*compt)++];
01658 tabcoeff[4]=p->nf[(*compt)++];
01659 tabcoeff[6]=p->nf[(*compt)++];
01660 tabcoeff[7]=p->nf[(*compt)++];
01661 }
01662 template<typename T>
01663 void egal215(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01664 {
01665 tabcoeff[0]=p->nf[(*compt)++];
01666 tabcoeff[1]=p->nf[(*compt)++];
01667 tabcoeff[2]=p->nf[(*compt)++];
01668 tabcoeff[4]=p->nf[(*compt)++];
01669 tabcoeff[6]=p->nf[(*compt)++];
01670 tabcoeff[7]=p->nf[(*compt)++];
01671 }
01672 template<typename T>
01673 void egal216(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01674 {
01675 tabcoeff[3]=p->nf[(*compt)++];
01676 tabcoeff[4]=p->nf[(*compt)++];
01677 tabcoeff[6]=p->nf[(*compt)++];
01678 tabcoeff[7]=p->nf[(*compt)++];
01679 }
01680 template<typename T>
01681 void egal217(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01682 {
01683 tabcoeff[0]=p->nf[(*compt)++];
01684 tabcoeff[3]=p->nf[(*compt)++];
01685 tabcoeff[4]=p->nf[(*compt)++];
01686 tabcoeff[6]=p->nf[(*compt)++];
01687 tabcoeff[7]=p->nf[(*compt)++];
01688 }
01689 template<typename T>
01690 void egal218(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01691 {
01692 tabcoeff[1]=p->nf[(*compt)++];
01693 tabcoeff[3]=p->nf[(*compt)++];
01694 tabcoeff[4]=p->nf[(*compt)++];
01695 tabcoeff[6]=p->nf[(*compt)++];
01696 tabcoeff[7]=p->nf[(*compt)++];
01697 }
01698 template<typename T>
01699 void egal219(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01700 {
01701 tabcoeff[0]=p->nf[(*compt)++];
01702 tabcoeff[1]=p->nf[(*compt)++];
01703 tabcoeff[3]=p->nf[(*compt)++];
01704 tabcoeff[4]=p->nf[(*compt)++];
01705 tabcoeff[6]=p->nf[(*compt)++];
01706 tabcoeff[7]=p->nf[(*compt)++];
01707 }
01708 template<typename T>
01709 void egal220(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01710 {
01711 tabcoeff[2]=p->nf[(*compt)++];
01712 tabcoeff[3]=p->nf[(*compt)++];
01713 tabcoeff[4]=p->nf[(*compt)++];
01714 tabcoeff[6]=p->nf[(*compt)++];
01715 tabcoeff[7]=p->nf[(*compt)++];
01716 }
01717 template<typename T>
01718 void egal221(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01719 {
01720 tabcoeff[0]=p->nf[(*compt)++];
01721 tabcoeff[2]=p->nf[(*compt)++];
01722 tabcoeff[3]=p->nf[(*compt)++];
01723 tabcoeff[4]=p->nf[(*compt)++];
01724 tabcoeff[6]=p->nf[(*compt)++];
01725 tabcoeff[7]=p->nf[(*compt)++];
01726 }
01727 template<typename T>
01728 void egal222(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01729 {
01730 tabcoeff[1]=p->nf[(*compt)++];
01731 tabcoeff[2]=p->nf[(*compt)++];
01732 tabcoeff[3]=p->nf[(*compt)++];
01733 tabcoeff[4]=p->nf[(*compt)++];
01734 tabcoeff[6]=p->nf[(*compt)++];
01735 tabcoeff[7]=p->nf[(*compt)++];
01736 }
01737 template<typename T>
01738 void egal223(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01739 {
01740 tabcoeff[0]=p->nf[(*compt)++];
01741 tabcoeff[1]=p->nf[(*compt)++];
01742 tabcoeff[2]=p->nf[(*compt)++];
01743 tabcoeff[3]=p->nf[(*compt)++];
01744 tabcoeff[4]=p->nf[(*compt)++];
01745 tabcoeff[6]=p->nf[(*compt)++];
01746 tabcoeff[7]=p->nf[(*compt)++];
01747 }
01748 template<typename T>
01749 void egal224(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01750 {
01751 tabcoeff[5]=p->nf[(*compt)++];
01752 tabcoeff[6]=p->nf[(*compt)++];
01753 tabcoeff[7]=p->nf[(*compt)++];
01754 }
01755 template<typename T>
01756 void egal225(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01757 {
01758 tabcoeff[0]=p->nf[(*compt)++];
01759 tabcoeff[5]=p->nf[(*compt)++];
01760 tabcoeff[6]=p->nf[(*compt)++];
01761 tabcoeff[7]=p->nf[(*compt)++];
01762 }
01763 template<typename T>
01764 void egal226(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01765 {
01766 tabcoeff[1]=p->nf[(*compt)++];
01767 tabcoeff[5]=p->nf[(*compt)++];
01768 tabcoeff[6]=p->nf[(*compt)++];
01769 tabcoeff[7]=p->nf[(*compt)++];
01770 }
01771 template<typename T>
01772 void egal227(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01773 {
01774 tabcoeff[0]=p->nf[(*compt)++];
01775 tabcoeff[1]=p->nf[(*compt)++];
01776 tabcoeff[5]=p->nf[(*compt)++];
01777 tabcoeff[6]=p->nf[(*compt)++];
01778 tabcoeff[7]=p->nf[(*compt)++];
01779 }
01780 template<typename T>
01781 void egal228(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01782 {
01783 tabcoeff[2]=p->nf[(*compt)++];
01784 tabcoeff[5]=p->nf[(*compt)++];
01785 tabcoeff[6]=p->nf[(*compt)++];
01786 tabcoeff[7]=p->nf[(*compt)++];
01787 }
01788 template<typename T>
01789 void egal229(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01790 {
01791 tabcoeff[0]=p->nf[(*compt)++];
01792 tabcoeff[2]=p->nf[(*compt)++];
01793 tabcoeff[5]=p->nf[(*compt)++];
01794 tabcoeff[6]=p->nf[(*compt)++];
01795 tabcoeff[7]=p->nf[(*compt)++];
01796 }
01797 template<typename T>
01798 void egal230(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01799 {
01800 tabcoeff[1]=p->nf[(*compt)++];
01801 tabcoeff[2]=p->nf[(*compt)++];
01802 tabcoeff[5]=p->nf[(*compt)++];
01803 tabcoeff[6]=p->nf[(*compt)++];
01804 tabcoeff[7]=p->nf[(*compt)++];
01805 }
01806 template<typename T>
01807 void egal231(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01808 {
01809 tabcoeff[0]=p->nf[(*compt)++];
01810 tabcoeff[1]=p->nf[(*compt)++];
01811 tabcoeff[2]=p->nf[(*compt)++];
01812 tabcoeff[5]=p->nf[(*compt)++];
01813 tabcoeff[6]=p->nf[(*compt)++];
01814 tabcoeff[7]=p->nf[(*compt)++];
01815 }
01816 template<typename T>
01817 void egal232(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01818 {
01819 tabcoeff[3]=p->nf[(*compt)++];
01820 tabcoeff[5]=p->nf[(*compt)++];
01821 tabcoeff[6]=p->nf[(*compt)++];
01822 tabcoeff[7]=p->nf[(*compt)++];
01823 }
01824 template<typename T>
01825 void egal233(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01826 {
01827 tabcoeff[0]=p->nf[(*compt)++];
01828 tabcoeff[3]=p->nf[(*compt)++];
01829 tabcoeff[5]=p->nf[(*compt)++];
01830 tabcoeff[6]=p->nf[(*compt)++];
01831 tabcoeff[7]=p->nf[(*compt)++];
01832 }
01833 template<typename T>
01834 void egal234(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01835 {
01836 tabcoeff[1]=p->nf[(*compt)++];
01837 tabcoeff[3]=p->nf[(*compt)++];
01838 tabcoeff[5]=p->nf[(*compt)++];
01839 tabcoeff[6]=p->nf[(*compt)++];
01840 tabcoeff[7]=p->nf[(*compt)++];
01841 }
01842 template<typename T>
01843 void egal235(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01844 {
01845 tabcoeff[0]=p->nf[(*compt)++];
01846 tabcoeff[1]=p->nf[(*compt)++];
01847 tabcoeff[3]=p->nf[(*compt)++];
01848 tabcoeff[5]=p->nf[(*compt)++];
01849 tabcoeff[6]=p->nf[(*compt)++];
01850 tabcoeff[7]=p->nf[(*compt)++];
01851 }
01852 template<typename T>
01853 void egal236(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01854 {
01855 tabcoeff[2]=p->nf[(*compt)++];
01856 tabcoeff[3]=p->nf[(*compt)++];
01857 tabcoeff[5]=p->nf[(*compt)++];
01858 tabcoeff[6]=p->nf[(*compt)++];
01859 tabcoeff[7]=p->nf[(*compt)++];
01860 }
01861 template<typename T>
01862 void egal237(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01863 {
01864 tabcoeff[0]=p->nf[(*compt)++];
01865 tabcoeff[2]=p->nf[(*compt)++];
01866 tabcoeff[3]=p->nf[(*compt)++];
01867 tabcoeff[5]=p->nf[(*compt)++];
01868 tabcoeff[6]=p->nf[(*compt)++];
01869 tabcoeff[7]=p->nf[(*compt)++];
01870 }
01871 template<typename T>
01872 void egal238(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01873 {
01874 tabcoeff[1]=p->nf[(*compt)++];
01875 tabcoeff[2]=p->nf[(*compt)++];
01876 tabcoeff[3]=p->nf[(*compt)++];
01877 tabcoeff[5]=p->nf[(*compt)++];
01878 tabcoeff[6]=p->nf[(*compt)++];
01879 tabcoeff[7]=p->nf[(*compt)++];
01880 }
01881 template<typename T>
01882 void egal239(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01883 {
01884 tabcoeff[0]=p->nf[(*compt)++];
01885 tabcoeff[1]=p->nf[(*compt)++];
01886 tabcoeff[2]=p->nf[(*compt)++];
01887 tabcoeff[3]=p->nf[(*compt)++];
01888 tabcoeff[5]=p->nf[(*compt)++];
01889 tabcoeff[6]=p->nf[(*compt)++];
01890 tabcoeff[7]=p->nf[(*compt)++];
01891 }
01892 template<typename T>
01893 void egal240(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01894 {
01895 tabcoeff[4]=p->nf[(*compt)++];
01896 tabcoeff[5]=p->nf[(*compt)++];
01897 tabcoeff[6]=p->nf[(*compt)++];
01898 tabcoeff[7]=p->nf[(*compt)++];
01899 }
01900 template<typename T>
01901 void egal241(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01902 {
01903 tabcoeff[0]=p->nf[(*compt)++];
01904 tabcoeff[4]=p->nf[(*compt)++];
01905 tabcoeff[5]=p->nf[(*compt)++];
01906 tabcoeff[6]=p->nf[(*compt)++];
01907 tabcoeff[7]=p->nf[(*compt)++];
01908 }
01909 template<typename T>
01910 void egal242(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01911 {
01912 tabcoeff[1]=p->nf[(*compt)++];
01913 tabcoeff[4]=p->nf[(*compt)++];
01914 tabcoeff[5]=p->nf[(*compt)++];
01915 tabcoeff[6]=p->nf[(*compt)++];
01916 tabcoeff[7]=p->nf[(*compt)++];
01917 }
01918 template<typename T>
01919 void egal243(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01920 {
01921 tabcoeff[0]=p->nf[(*compt)++];
01922 tabcoeff[1]=p->nf[(*compt)++];
01923 tabcoeff[4]=p->nf[(*compt)++];
01924 tabcoeff[5]=p->nf[(*compt)++];
01925 tabcoeff[6]=p->nf[(*compt)++];
01926 tabcoeff[7]=p->nf[(*compt)++];
01927 }
01928 template<typename T>
01929 void egal244(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01930 {
01931 tabcoeff[2]=p->nf[(*compt)++];
01932 tabcoeff[4]=p->nf[(*compt)++];
01933 tabcoeff[5]=p->nf[(*compt)++];
01934 tabcoeff[6]=p->nf[(*compt)++];
01935 tabcoeff[7]=p->nf[(*compt)++];
01936 }
01937 template<typename T>
01938 void egal245(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01939 {
01940 tabcoeff[0]=p->nf[(*compt)++];
01941 tabcoeff[2]=p->nf[(*compt)++];
01942 tabcoeff[4]=p->nf[(*compt)++];
01943 tabcoeff[5]=p->nf[(*compt)++];
01944 tabcoeff[6]=p->nf[(*compt)++];
01945 tabcoeff[7]=p->nf[(*compt)++];
01946 }
01947 template<typename T>
01948 void egal246(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01949 {
01950 tabcoeff[1]=p->nf[(*compt)++];
01951 tabcoeff[2]=p->nf[(*compt)++];
01952 tabcoeff[4]=p->nf[(*compt)++];
01953 tabcoeff[5]=p->nf[(*compt)++];
01954 tabcoeff[6]=p->nf[(*compt)++];
01955 tabcoeff[7]=p->nf[(*compt)++];
01956 }
01957 template<typename T>
01958 void egal247(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01959 {
01960 tabcoeff[0]=p->nf[(*compt)++];
01961 tabcoeff[1]=p->nf[(*compt)++];
01962 tabcoeff[2]=p->nf[(*compt)++];
01963 tabcoeff[4]=p->nf[(*compt)++];
01964 tabcoeff[5]=p->nf[(*compt)++];
01965 tabcoeff[6]=p->nf[(*compt)++];
01966 tabcoeff[7]=p->nf[(*compt)++];
01967 }
01968 template<typename T>
01969 void egal248(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01970 {
01971 tabcoeff[3]=p->nf[(*compt)++];
01972 tabcoeff[4]=p->nf[(*compt)++];
01973 tabcoeff[5]=p->nf[(*compt)++];
01974 tabcoeff[6]=p->nf[(*compt)++];
01975 tabcoeff[7]=p->nf[(*compt)++];
01976 }
01977 template<typename T>
01978 void egal249(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01979 {
01980 tabcoeff[0]=p->nf[(*compt)++];
01981 tabcoeff[3]=p->nf[(*compt)++];
01982 tabcoeff[4]=p->nf[(*compt)++];
01983 tabcoeff[5]=p->nf[(*compt)++];
01984 tabcoeff[6]=p->nf[(*compt)++];
01985 tabcoeff[7]=p->nf[(*compt)++];
01986 }
01987 template<typename T>
01988 void egal250(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01989 {
01990 tabcoeff[1]=p->nf[(*compt)++];
01991 tabcoeff[3]=p->nf[(*compt)++];
01992 tabcoeff[4]=p->nf[(*compt)++];
01993 tabcoeff[5]=p->nf[(*compt)++];
01994 tabcoeff[6]=p->nf[(*compt)++];
01995 tabcoeff[7]=p->nf[(*compt)++];
01996 }
01997 template<typename T>
01998 void egal251(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
01999 {
02000 tabcoeff[0]=p->nf[(*compt)++];
02001 tabcoeff[1]=p->nf[(*compt)++];
02002 tabcoeff[3]=p->nf[(*compt)++];
02003 tabcoeff[4]=p->nf[(*compt)++];
02004 tabcoeff[5]=p->nf[(*compt)++];
02005 tabcoeff[6]=p->nf[(*compt)++];
02006 tabcoeff[7]=p->nf[(*compt)++];
02007 }
02008 template<typename T>
02009 void egal252(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
02010 {
02011 tabcoeff[2]=p->nf[(*compt)++];
02012 tabcoeff[3]=p->nf[(*compt)++];
02013 tabcoeff[4]=p->nf[(*compt)++];
02014 tabcoeff[5]=p->nf[(*compt)++];
02015 tabcoeff[6]=p->nf[(*compt)++];
02016 tabcoeff[7]=p->nf[(*compt)++];
02017 }
02018 template<typename T>
02019 void egal253(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
02020 {
02021 tabcoeff[0]=p->nf[(*compt)++];
02022 tabcoeff[2]=p->nf[(*compt)++];
02023 tabcoeff[3]=p->nf[(*compt)++];
02024 tabcoeff[4]=p->nf[(*compt)++];
02025 tabcoeff[5]=p->nf[(*compt)++];
02026 tabcoeff[6]=p->nf[(*compt)++];
02027 tabcoeff[7]=p->nf[(*compt)++];
02028 }
02029 template<typename T>
02030 void egal254(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
02031 {
02032 tabcoeff[1]=p->nf[(*compt)++];
02033 tabcoeff[2]=p->nf[(*compt)++];
02034 tabcoeff[3]=p->nf[(*compt)++];
02035 tabcoeff[4]=p->nf[(*compt)++];
02036 tabcoeff[5]=p->nf[(*compt)++];
02037 tabcoeff[6]=p->nf[(*compt)++];
02038 tabcoeff[7]=p->nf[(*compt)++];
02039 }
02040 template<typename T>
02041 void egal255(COEFF * tabcoeff, pol<mon,T> *p, int *compt)
02042 {
02043 tabcoeff[0]=p->nf[(*compt)++];
02044 tabcoeff[1]=p->nf[(*compt)++];
02045 tabcoeff[2]=p->nf[(*compt)++];
02046 tabcoeff[3]=p->nf[(*compt)++];
02047 tabcoeff[4]=p->nf[(*compt)++];
02048 tabcoeff[5]=p->nf[(*compt)++];
02049 tabcoeff[6]=p->nf[(*compt)++];
02050 tabcoeff[7]=p->nf[(*compt)++];
02051 }
02052 //---------------------------------------------------------------
02053 template<typename T>
02054 void moinsegal0(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02055 {
02056 }
02057 template<typename T>
02058 void moinsegal1(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02059 {
02060 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02061 }
02062 template<typename T>
02063 void moinsegal2(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02064 {
02065 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02066 }
02067 template<typename T>
02068 void moinsegal3(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02069 {
02070 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02071 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02072 }
02073 template<typename T>
02074 void moinsegal4(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02075 {
02076 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02077 }
02078 template<typename T>
02079 void moinsegal5(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02080 {
02081 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02082 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02083 }
02084 template<typename T>
02085 void moinsegal6(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02086 {
02087 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02088 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02089 }
02090 template<typename T>
02091 void moinsegal7(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02092 {
02093 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02094 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02095 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02096 }
02097 template<typename T>
02098 void moinsegal8(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02099 {
02100 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02101 }
02102 template<typename T>
02103 void moinsegal9(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02104 {
02105 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02106 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02107 }
02108 template<typename T>
02109 void moinsegal10(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02110 {
02111 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02112 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02113 }
02114 template<typename T>
02115 void moinsegal11(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02116 {
02117 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02118 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02119 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02120 }
02121 template<typename T>
02122 void moinsegal12(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02123 {
02124 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02125 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02126 }
02127 template<typename T>
02128 void moinsegal13(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02129 {
02130 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02131 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02132 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02133 }
02134 template<typename T>
02135 void moinsegal14(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02136 {
02137 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02138 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02139 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02140 }
02141 template<typename T>
02142 void moinsegal15(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02143 {
02144 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02145 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02146 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02147 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02148 }
02149 template<typename T>
02150 void moinsegal16(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02151 {
02152 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02153 }
02154 template<typename T>
02155 void moinsegal17(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02156 {
02157 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02158 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02159 }
02160 template<typename T>
02161 void moinsegal18(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02162 {
02163 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02164 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02165 }
02166 template<typename T>
02167 void moinsegal19(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02168 {
02169 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02170 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02171 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02172 }
02173 template<typename T>
02174 void moinsegal20(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02175 {
02176 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02177 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02178 }
02179 template<typename T>
02180 void moinsegal21(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02181 {
02182 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02183 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02184 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02185 }
02186 template<typename T>
02187 void moinsegal22(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02188 {
02189 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02190 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02191 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02192 }
02193 template<typename T>
02194 void moinsegal23(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02195 {
02196 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02197 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02198 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02199 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02200 }
02201 template<typename T>
02202 void moinsegal24(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02203 {
02204 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02205 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02206 }
02207 template<typename T>
02208 void moinsegal25(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02209 {
02210 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02211 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02212 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02213 }
02214 template<typename T>
02215 void moinsegal26(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02216 {
02217 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02218 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02219 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02220 }
02221 template<typename T>
02222 void moinsegal27(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02223 {
02224 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02225 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02226 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02227 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02228 }
02229 template<typename T>
02230 void moinsegal28(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02231 {
02232 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02233 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02234 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02235 }
02236 template<typename T>
02237 void moinsegal29(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02238 {
02239 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02240 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02241 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02242 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02243 }
02244 template<typename T>
02245 void moinsegal30(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02246 {
02247 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02248 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02249 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02250 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02251 }
02252 template<typename T>
02253 void moinsegal31(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02254 {
02255 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02256 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02257 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02258 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02259 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02260 }
02261 template<typename T>
02262 void moinsegal32(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02263 {
02264 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02265 }
02266 template<typename T>
02267 void moinsegal33(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02268 {
02269 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02270 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02271 }
02272 template<typename T>
02273 void moinsegal34(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02274 {
02275 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02276 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02277 }
02278 template<typename T>
02279 void moinsegal35(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02280 {
02281 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02282 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02283 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02284 }
02285 template<typename T>
02286 void moinsegal36(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02287 {
02288 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02289 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02290 }
02291 template<typename T>
02292 void moinsegal37(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02293 {
02294 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02295 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02296 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02297 }
02298 template<typename T>
02299 void moinsegal38(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02300 {
02301 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02302 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02303 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02304 }
02305 template<typename T>
02306 void moinsegal39(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02307 {
02308 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02309 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02310 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02311 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02312 }
02313 template<typename T>
02314 void moinsegal40(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02315 {
02316 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02317 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02318 }
02319 template<typename T>
02320 void moinsegal41(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02321 {
02322 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02323 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02324 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02325 }
02326 template<typename T>
02327 void moinsegal42(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02328 {
02329 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02330 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02331 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02332 }
02333 template<typename T>
02334 void moinsegal43(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02335 {
02336 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02337 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02338 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02339 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02340 }
02341 template<typename T>
02342 void moinsegal44(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02343 {
02344 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02345 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02346 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02347 }
02348 template<typename T>
02349 void moinsegal45(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02350 {
02351 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02352 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02353 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02354 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02355 }
02356 template<typename T>
02357 void moinsegal46(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02358 {
02359 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02360 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02361 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02362 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02363 }
02364 template<typename T>
02365 void moinsegal47(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02366 {
02367 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02368 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02369 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02370 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02371 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02372 }
02373 template<typename T>
02374 void moinsegal48(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02375 {
02376 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02377 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02378 }
02379 template<typename T>
02380 void moinsegal49(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02381 {
02382 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02383 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02384 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02385 }
02386 template<typename T>
02387 void moinsegal50(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02388 {
02389 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02390 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02391 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02392 }
02393 template<typename T>
02394 void moinsegal51(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02395 {
02396 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02397 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02398 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02399 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02400 }
02401 template<typename T>
02402 void moinsegal52(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02403 {
02404 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02405 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02406 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02407 }
02408 template<typename T>
02409 void moinsegal53(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02410 {
02411 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02412 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02413 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02414 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02415 }
02416 template<typename T>
02417 void moinsegal54(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02418 {
02419 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02420 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02421 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02422 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02423 }
02424 template<typename T>
02425 void moinsegal55(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02426 {
02427 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02428 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02429 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02430 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02431 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02432 }
02433 template<typename T>
02434 void moinsegal56(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02435 {
02436 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02437 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02438 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02439 }
02440 template<typename T>
02441 void moinsegal57(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02442 {
02443 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02444 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02445 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02446 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02447 }
02448 template<typename T>
02449 void moinsegal58(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02450 {
02451 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02452 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02453 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02454 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02455 }
02456 template<typename T>
02457 void moinsegal59(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02458 {
02459 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02460 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02461 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02462 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02463 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02464 }
02465 template<typename T>
02466 void moinsegal60(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02467 {
02468 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02469 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02470 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02471 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02472 }
02473 template<typename T>
02474 void moinsegal61(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02475 {
02476 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02477 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02478 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02479 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02480 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02481 }
02482 template<typename T>
02483 void moinsegal62(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02484 {
02485 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02486 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02487 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02488 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02489 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02490 }
02491 template<typename T>
02492 void moinsegal63(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02493 {
02494 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02495 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02496 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02497 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02498 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02499 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02500 }
02501 template<typename T>
02502 void moinsegal64(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02503 {
02504 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02505 }
02506 template<typename T>
02507 void moinsegal65(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02508 {
02509 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02510 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02511 }
02512 template<typename T>
02513 void moinsegal66(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02514 {
02515 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02516 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02517 }
02518 template<typename T>
02519 void moinsegal67(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02520 {
02521 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02522 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02523 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02524 }
02525 template<typename T>
02526 void moinsegal68(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02527 {
02528 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02529 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02530 }
02531 template<typename T>
02532 void moinsegal69(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02533 {
02534 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02535 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02536 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02537 }
02538 template<typename T>
02539 void moinsegal70(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02540 {
02541 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02542 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02543 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02544 }
02545 template<typename T>
02546 void moinsegal71(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02547 {
02548 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02549 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02550 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02551 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02552 }
02553 template<typename T>
02554 void moinsegal72(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02555 {
02556 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02557 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02558 }
02559 template<typename T>
02560 void moinsegal73(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02561 {
02562 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02563 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02564 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02565 }
02566 template<typename T>
02567 void moinsegal74(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02568 {
02569 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02570 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02571 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02572 }
02573 template<typename T>
02574 void moinsegal75(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02575 {
02576 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02577 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02578 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02579 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02580 }
02581 template<typename T>
02582 void moinsegal76(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02583 {
02584 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02585 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02586 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02587 }
02588 template<typename T>
02589 void moinsegal77(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02590 {
02591 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02592 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02593 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02594 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02595 }
02596 template<typename T>
02597 void moinsegal78(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02598 {
02599 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02600 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02601 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02602 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02603 }
02604 template<typename T>
02605 void moinsegal79(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02606 {
02607 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02608 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02609 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02610 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02611 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02612 }
02613 template<typename T>
02614 void moinsegal80(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02615 {
02616 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02617 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02618 }
02619 template<typename T>
02620 void moinsegal81(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02621 {
02622 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02623 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02624 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02625 }
02626 template<typename T>
02627 void moinsegal82(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02628 {
02629 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02630 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02631 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02632 }
02633 template<typename T>
02634 void moinsegal83(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02635 {
02636 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02637 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02638 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02639 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02640 }
02641 template<typename T>
02642 void moinsegal84(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02643 {
02644 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02645 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02646 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02647 }
02648 template<typename T>
02649 void moinsegal85(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02650 {
02651 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02652 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02653 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02654 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02655 }
02656 template<typename T>
02657 void moinsegal86(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02658 {
02659 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02660 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02661 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02662 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02663 }
02664 template<typename T>
02665 void moinsegal87(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02666 {
02667 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02668 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02669 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02670 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02671 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02672 }
02673 template<typename T>
02674 void moinsegal88(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02675 {
02676 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02677 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02678 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02679 }
02680 template<typename T>
02681 void moinsegal89(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02682 {
02683 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02684 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02685 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02686 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02687 }
02688 template<typename T>
02689 void moinsegal90(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02690 {
02691 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02692 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02693 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02694 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02695 }
02696 template<typename T>
02697 void moinsegal91(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02698 {
02699 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02700 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02701 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02702 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02703 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02704 }
02705 template<typename T>
02706 void moinsegal92(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02707 {
02708 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02709 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02710 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02711 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02712 }
02713 template<typename T>
02714 void moinsegal93(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02715 {
02716 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02717 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02718 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02719 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02720 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02721 }
02722 template<typename T>
02723 void moinsegal94(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02724 {
02725 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02726 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02727 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02728 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02729 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02730 }
02731 template<typename T>
02732 void moinsegal95(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02733 {
02734 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02735 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02736 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02737 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02738 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02739 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02740 }
02741 template<typename T>
02742 void moinsegal96(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02743 {
02744 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02745 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02746 }
02747 template<typename T>
02748 void moinsegal97(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02749 {
02750 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02751 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02752 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02753 }
02754 template<typename T>
02755 void moinsegal98(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02756 {
02757 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02758 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02759 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02760 }
02761 template<typename T>
02762 void moinsegal99(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02763 {
02764 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02765 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02766 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02767 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02768 }
02769 template<typename T>
02770 void moinsegal100(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02771 {
02772 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02773 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02774 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02775 }
02776 template<typename T>
02777 void moinsegal101(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02778 {
02779 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02780 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02781 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02782 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02783 }
02784 template<typename T>
02785 void moinsegal102(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02786 {
02787 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02788 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02789 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02790 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02791 }
02792 template<typename T>
02793 void moinsegal103(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02794 {
02795 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02796 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02797 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02798 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02799 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02800 }
02801 template<typename T>
02802 void moinsegal104(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02803 {
02804 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02805 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02806 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02807 }
02808 template<typename T>
02809 void moinsegal105(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02810 {
02811 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02812 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02813 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02814 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02815 }
02816 template<typename T>
02817 void moinsegal106(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02818 {
02819 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02820 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02821 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02822 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02823 }
02824 template<typename T>
02825 void moinsegal107(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02826 {
02827 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02828 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02829 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02830 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02831 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02832 }
02833 template<typename T>
02834 void moinsegal108(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02835 {
02836 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02837 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02838 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02839 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02840 }
02841 template<typename T>
02842 void moinsegal109(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02843 {
02844 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02845 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02846 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02847 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02848 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02849 }
02850 template<typename T>
02851 void moinsegal110(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02852 {
02853 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02854 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02855 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02856 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02857 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02858 }
02859 template<typename T>
02860 void moinsegal111(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02861 {
02862 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02863 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02864 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02865 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02866 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02867 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02868 }
02869 template<typename T>
02870 void moinsegal112(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02871 {
02872 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02873 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02874 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02875 }
02876 template<typename T>
02877 void moinsegal113(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02878 {
02879 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02880 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02881 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02882 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02883 }
02884 template<typename T>
02885 void moinsegal114(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02886 {
02887 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02888 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02889 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02890 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02891 }
02892 template<typename T>
02893 void moinsegal115(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02894 {
02895 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02896 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02897 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02898 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02899 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02900 }
02901 template<typename T>
02902 void moinsegal116(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02903 {
02904 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02905 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02906 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02907 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02908 }
02909 template<typename T>
02910 void moinsegal117(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02911 {
02912 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02913 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02914 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02915 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02916 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02917 }
02918 template<typename T>
02919 void moinsegal118(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02920 {
02921 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02922 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02923 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02924 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02925 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02926 }
02927 template<typename T>
02928 void moinsegal119(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02929 {
02930 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02931 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02932 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02933 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02934 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02935 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02936 }
02937 template<typename T>
02938 void moinsegal120(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02939 {
02940 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02941 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02942 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02943 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02944 }
02945 template<typename T>
02946 void moinsegal121(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02947 {
02948 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02949 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02950 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02951 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02952 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02953 }
02954 template<typename T>
02955 void moinsegal122(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02956 {
02957 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02958 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02959 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02960 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02961 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02962 }
02963 template<typename T>
02964 void moinsegal123(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02965 {
02966 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02967 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02968 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02969 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02970 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02971 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02972 }
02973 template<typename T>
02974 void moinsegal124(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02975 {
02976 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02977 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02978 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02979 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02980 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02981 }
02982 template<typename T>
02983 void moinsegal125(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02984 {
02985 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
02986 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02987 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02988 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02989 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
02990 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
02991 }
02992 template<typename T>
02993 void moinsegal126(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
02994 {
02995 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
02996 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
02997 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
02998 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
02999 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03000 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03001 }
03002 template<typename T>
03003 void moinsegal127(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03004 {
03005 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03006 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03007 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03008 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03009 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03010 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03011 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03012 }
03013 template<typename T>
03014 void moinsegal128(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03015 {
03016 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03017 }
03018 template<typename T>
03019 void moinsegal129(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03020 {
03021 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03022 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03023 }
03024 template<typename T>
03025 void moinsegal130(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03026 {
03027 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03028 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03029 }
03030 template<typename T>
03031 void moinsegal131(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03032 {
03033 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03034 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03035 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03036 }
03037 template<typename T>
03038 void moinsegal132(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03039 {
03040 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03041 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03042 }
03043 template<typename T>
03044 void moinsegal133(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03045 {
03046 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03047 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03048 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03049 }
03050 template<typename T>
03051 void moinsegal134(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03052 {
03053 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03054 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03055 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03056 }
03057 template<typename T>
03058 void moinsegal135(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03059 {
03060 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03061 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03062 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03063 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03064 }
03065 template<typename T>
03066 void moinsegal136(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03067 {
03068 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03069 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03070 }
03071 template<typename T>
03072 void moinsegal137(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03073 {
03074 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03075 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03076 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03077 }
03078 template<typename T>
03079 void moinsegal138(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03080 {
03081 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03082 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03083 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03084 }
03085 template<typename T>
03086 void moinsegal139(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03087 {
03088 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03089 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03090 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03091 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03092 }
03093 template<typename T>
03094 void moinsegal140(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03095 {
03096 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03097 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03098 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03099 }
03100 template<typename T>
03101 void moinsegal141(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03102 {
03103 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03104 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03105 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03106 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03107 }
03108 template<typename T>
03109 void moinsegal142(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03110 {
03111 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03112 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03113 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03114 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03115 }
03116 template<typename T>
03117 void moinsegal143(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03118 {
03119 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03120 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03121 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03122 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03123 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03124 }
03125 template<typename T>
03126 void moinsegal144(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03127 {
03128 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03129 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03130 }
03131 template<typename T>
03132 void moinsegal145(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03133 {
03134 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03135 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03136 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03137 }
03138 template<typename T>
03139 void moinsegal146(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03140 {
03141 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03142 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03143 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03144 }
03145 template<typename T>
03146 void moinsegal147(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03147 {
03148 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03149 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03150 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03151 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03152 }
03153 template<typename T>
03154 void moinsegal148(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03155 {
03156 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03157 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03158 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03159 }
03160 template<typename T>
03161 void moinsegal149(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03162 {
03163 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03164 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03165 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03166 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03167 }
03168 template<typename T>
03169 void moinsegal150(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03170 {
03171 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03172 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03173 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03174 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03175 }
03176 template<typename T>
03177 void moinsegal151(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03178 {
03179 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03180 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03181 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03182 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03183 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03184 }
03185 template<typename T>
03186 void moinsegal152(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03187 {
03188 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03189 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03190 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03191 }
03192 template<typename T>
03193 void moinsegal153(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03194 {
03195 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03196 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03197 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03198 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03199 }
03200 template<typename T>
03201 void moinsegal154(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03202 {
03203 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03204 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03205 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03206 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03207 }
03208 template<typename T>
03209 void moinsegal155(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03210 {
03211 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03212 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03213 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03214 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03215 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03216 }
03217 template<typename T>
03218 void moinsegal156(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03219 {
03220 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03221 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03222 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03223 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03224 }
03225 template<typename T>
03226 void moinsegal157(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03227 {
03228 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03229 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03230 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03231 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03232 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03233 }
03234 template<typename T>
03235 void moinsegal158(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03236 {
03237 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03238 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03239 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03240 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03241 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03242 }
03243 template<typename T>
03244 void moinsegal159(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03245 {
03246 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03247 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03248 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03249 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03250 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03251 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03252 }
03253 template<typename T>
03254 void moinsegal160(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03255 {
03256 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03257 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03258 }
03259 template<typename T>
03260 void moinsegal161(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03261 {
03262 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03263 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03264 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03265 }
03266 template<typename T>
03267 void moinsegal162(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03268 {
03269 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03270 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03271 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03272 }
03273 template<typename T>
03274 void moinsegal163(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03275 {
03276 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03277 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03278 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03279 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03280 }
03281 template<typename T>
03282 void moinsegal164(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03283 {
03284 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03285 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03286 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03287 }
03288 template<typename T>
03289 void moinsegal165(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03290 {
03291 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03292 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03293 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03294 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03295 }
03296 template<typename T>
03297 void moinsegal166(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03298 {
03299 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03300 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03301 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03302 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03303 }
03304 template<typename T>
03305 void moinsegal167(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03306 {
03307 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03308 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03309 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03310 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03311 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03312 }
03313 template<typename T>
03314 void moinsegal168(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03315 {
03316 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03317 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03318 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03319 }
03320 template<typename T>
03321 void moinsegal169(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03322 {
03323 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03324 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03325 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03326 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03327 }
03328 template<typename T>
03329 void moinsegal170(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03330 {
03331 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03332 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03333 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03334 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03335 }
03336 template<typename T>
03337 void moinsegal171(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03338 {
03339 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03340 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03341 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03342 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03343 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03344 }
03345 template<typename T>
03346 void moinsegal172(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03347 {
03348 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03349 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03350 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03351 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03352 }
03353 template<typename T>
03354 void moinsegal173(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03355 {
03356 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03357 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03358 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03359 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03360 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03361 }
03362 template<typename T>
03363 void moinsegal174(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03364 {
03365 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03366 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03367 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03368 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03369 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03370 }
03371 template<typename T>
03372 void moinsegal175(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03373 {
03374 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03375 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03376 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03377 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03378 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03379 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03380 }
03381 template<typename T>
03382 void moinsegal176(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03383 {
03384 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03385 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03386 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03387 }
03388 template<typename T>
03389 void moinsegal177(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03390 {
03391 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03392 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03393 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03394 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03395 }
03396 template<typename T>
03397 void moinsegal178(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03398 {
03399 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03400 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03401 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03402 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03403 }
03404 template<typename T>
03405 void moinsegal179(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03406 {
03407 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03408 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03409 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03410 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03411 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03412 }
03413 template<typename T>
03414 void moinsegal180(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03415 {
03416 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03417 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03418 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03419 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03420 }
03421 template<typename T>
03422 void moinsegal181(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03423 {
03424 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03425 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03426 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03427 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03428 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03429 }
03430 template<typename T>
03431 void moinsegal182(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03432 {
03433 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03434 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03435 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03436 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03437 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03438 }
03439 template<typename T>
03440 void moinsegal183(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03441 {
03442 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03443 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03444 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03445 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03446 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03447 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03448 }
03449 template<typename T>
03450 void moinsegal184(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03451 {
03452 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03453 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03454 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03455 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03456 }
03457 template<typename T>
03458 void moinsegal185(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03459 {
03460 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03461 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03462 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03463 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03464 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03465 }
03466 template<typename T>
03467 void moinsegal186(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03468 {
03469 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03470 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03471 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03472 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03473 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03474 }
03475 template<typename T>
03476 void moinsegal187(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03477 {
03478 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03479 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03480 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03481 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03482 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03483 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03484 }
03485 template<typename T>
03486 void moinsegal188(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03487 {
03488 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03489 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03490 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03491 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03492 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03493 }
03494 template<typename T>
03495 void moinsegal189(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03496 {
03497 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03498 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03499 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03500 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03501 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03502 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03503 }
03504 template<typename T>
03505 void moinsegal190(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03506 {
03507 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03508 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03509 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03510 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03511 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03512 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03513 }
03514 template<typename T>
03515 void moinsegal191(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03516 {
03517 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03518 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03519 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03520 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03521 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03522 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03523 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03524 }
03525 template<typename T>
03526 void moinsegal192(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03527 {
03528 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03529 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03530 }
03531 template<typename T>
03532 void moinsegal193(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03533 {
03534 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03535 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03536 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03537 }
03538 template<typename T>
03539 void moinsegal194(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03540 {
03541 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03542 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03543 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03544 }
03545 template<typename T>
03546 void moinsegal195(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03547 {
03548 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03549 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03550 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03551 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03552 }
03553 template<typename T>
03554 void moinsegal196(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03555 {
03556 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03557 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03558 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03559 }
03560 template<typename T>
03561 void moinsegal197(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03562 {
03563 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03564 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03565 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03566 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03567 }
03568 template<typename T>
03569 void moinsegal198(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03570 {
03571 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03572 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03573 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03574 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03575 }
03576 template<typename T>
03577 void moinsegal199(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03578 {
03579 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03580 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03581 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03582 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03583 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03584 }
03585 template<typename T>
03586 void moinsegal200(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03587 {
03588 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03589 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03590 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03591 }
03592 template<typename T>
03593 void moinsegal201(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03594 {
03595 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03596 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03597 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03598 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03599 }
03600 template<typename T>
03601 void moinsegal202(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03602 {
03603 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03604 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03605 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03606 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03607 }
03608 template<typename T>
03609 void moinsegal203(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03610 {
03611 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03612 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03613 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03614 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03615 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03616 }
03617 template<typename T>
03618 void moinsegal204(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03619 {
03620 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03621 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03622 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03623 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03624 }
03625 template<typename T>
03626 void moinsegal205(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03627 {
03628 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03629 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03630 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03631 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03632 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03633 }
03634 template<typename T>
03635 void moinsegal206(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03636 {
03637 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03638 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03639 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03640 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03641 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03642 }
03643 template<typename T>
03644 void moinsegal207(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03645 {
03646 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03647 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03648 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03649 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03650 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03651 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03652 }
03653 template<typename T>
03654 void moinsegal208(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03655 {
03656 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03657 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03658 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03659 }
03660 template<typename T>
03661 void moinsegal209(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03662 {
03663 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03664 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03665 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03666 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03667 }
03668 template<typename T>
03669 void moinsegal210(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03670 {
03671 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03672 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03673 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03674 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03675 }
03676 template<typename T>
03677 void moinsegal211(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03678 {
03679 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03680 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03681 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03682 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03683 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03684 }
03685 template<typename T>
03686 void moinsegal212(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03687 {
03688 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03689 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03690 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03691 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03692 }
03693 template<typename T>
03694 void moinsegal213(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03695 {
03696 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03697 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03698 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03699 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03700 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03701 }
03702 template<typename T>
03703 void moinsegal214(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03704 {
03705 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03706 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03707 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03708 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03709 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03710 }
03711 template<typename T>
03712 void moinsegal215(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03713 {
03714 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03715 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03716 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03717 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03718 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03719 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03720 }
03721 template<typename T>
03722 void moinsegal216(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03723 {
03724 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03725 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03726 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03727 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03728 }
03729 template<typename T>
03730 void moinsegal217(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03731 {
03732 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03733 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03734 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03735 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03736 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03737 }
03738 template<typename T>
03739 void moinsegal218(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03740 {
03741 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03742 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03743 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03744 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03745 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03746 }
03747 template<typename T>
03748 void moinsegal219(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03749 {
03750 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03751 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03752 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03753 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03754 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03755 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03756 }
03757 template<typename T>
03758 void moinsegal220(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03759 {
03760 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03761 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03762 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03763 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03764 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03765 }
03766 template<typename T>
03767 void moinsegal221(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03768 {
03769 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03770 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03771 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03772 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03773 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03774 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03775 }
03776 template<typename T>
03777 void moinsegal222(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03778 {
03779 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03780 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03781 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03782 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03783 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03784 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03785 }
03786 template<typename T>
03787 void moinsegal223(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03788 {
03789 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03790 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03791 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03792 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03793 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03794 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03795 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03796 }
03797 template<typename T>
03798 void moinsegal224(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03799 {
03800 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03801 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03802 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03803 }
03804 template<typename T>
03805 void moinsegal225(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03806 {
03807 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03808 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03809 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03810 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03811 }
03812 template<typename T>
03813 void moinsegal226(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03814 {
03815 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03816 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03817 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03818 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03819 }
03820 template<typename T>
03821 void moinsegal227(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03822 {
03823 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03824 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03825 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03826 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03827 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03828 }
03829 template<typename T>
03830 void moinsegal228(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03831 {
03832 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03833 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03834 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03835 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03836 }
03837 template<typename T>
03838 void moinsegal229(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03839 {
03840 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03841 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03842 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03843 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03844 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03845 }
03846 template<typename T>
03847 void moinsegal230(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03848 {
03849 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03850 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03851 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03852 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03853 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03854 }
03855 template<typename T>
03856 void moinsegal231(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03857 {
03858 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03859 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03860 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03861 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03862 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03863 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03864 }
03865 template<typename T>
03866 void moinsegal232(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03867 {
03868 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03869 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03870 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03871 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03872 }
03873 template<typename T>
03874 void moinsegal233(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03875 {
03876 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03877 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03878 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03879 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03880 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03881 }
03882 template<typename T>
03883 void moinsegal234(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03884 {
03885 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03886 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03887 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03888 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03889 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03890 }
03891 template<typename T>
03892 void moinsegal235(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03893 {
03894 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03895 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03896 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03897 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03898 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03899 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03900 }
03901 template<typename T>
03902 void moinsegal236(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03903 {
03904 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03905 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03906 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03907 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03908 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03909 }
03910 template<typename T>
03911 void moinsegal237(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03912 {
03913 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03914 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03915 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03916 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03917 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03918 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03919 }
03920 template<typename T>
03921 void moinsegal238(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03922 {
03923 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03924 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03925 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03926 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03927 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03928 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03929 }
03930 template<typename T>
03931 void moinsegal239(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03932 {
03933 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03934 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03935 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03936 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
03937 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03938 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03939 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03940 }
03941 template<typename T>
03942 void moinsegal240(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03943 {
03944 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03945 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03946 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03947 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03948 }
03949 template<typename T>
03950 void moinsegal241(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03951 {
03952 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03953 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03954 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03955 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03956 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03957 }
03958 template<typename T>
03959 void moinsegal242(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03960 {
03961 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03962 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03963 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03964 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03965 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03966 }
03967 template<typename T>
03968 void moinsegal243(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03969 {
03970 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03971 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
03972 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03973 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03974 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03975 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03976 }
03977 template<typename T>
03978 void moinsegal244(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03979 {
03980 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03981 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03982 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03983 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03984 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03985 }
03986 template<typename T>
03987 void moinsegal245(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03988 {
03989 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
03990 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
03991 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
03992 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
03993 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
03994 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
03995 }
03996 template<typename T>
03997 void moinsegal246(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
03998 {
03999 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
04000 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
04001 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
04002 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
04003 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
04004 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
04005 }
04006 template<typename T>
04007 void moinsegal247(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
04008 {
04009 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
04010 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
04011 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
04012 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
04013 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
04014 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
04015 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
04016 }
04017 template<typename T>
04018 void moinsegal248(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
04019 {
04020 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
04021 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
04022 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
04023 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
04024 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
04025 }
04026 template<typename T>
04027 void moinsegal249(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
04028 {
04029 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
04030 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
04031 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
04032 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
04033 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
04034 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
04035 }
04036 template<typename T>
04037 void moinsegal250(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
04038 {
04039 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
04040 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
04041 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
04042 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
04043 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
04044 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
04045 }
04046 template<typename T>
04047 void moinsegal251(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
04048 {
04049 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
04050 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
04051 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
04052 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
04053 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
04054 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
04055 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
04056 }
04057 template<typename T>
04058 void moinsegal252(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
04059 {
04060 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
04061 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
04062 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
04063 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
04064 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
04065 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
04066 }
04067 template<typename T>
04068 void moinsegal253(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
04069 {
04070 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
04071 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
04072 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
04073 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
04074 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
04075 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
04076 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
04077 }
04078 template<typename T>
04079 void moinsegal254(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
04080 {
04081 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
04082 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
04083 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
04084 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
04085 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
04086 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
04087 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
04088 }
04089 template<typename T>
04090 void moinsegal255(COEFF * tabcoeff, COEFF *tmpcoeff, pol<mon,T> *p, int *compt)
04091 {
04092 tabcoeff[0]-=*tmpcoeff*p->nf[(*compt)++];
04093 tabcoeff[1]-=*tmpcoeff*p->nf[(*compt)++];
04094 tabcoeff[2]-=*tmpcoeff*p->nf[(*compt)++];
04095 tabcoeff[3]-=*tmpcoeff*p->nf[(*compt)++];
04096 tabcoeff[4]-=*tmpcoeff*p->nf[(*compt)++];
04097 tabcoeff[5]-=*tmpcoeff*p->nf[(*compt)++];
04098 tabcoeff[6]-=*tmpcoeff*p->nf[(*compt)++];
04099 tabcoeff[7]-=*tmpcoeff*p->nf[(*compt)++];
04100 }
04101 
04102 void (*tabfun1[256])(COEFF *, pol<mon,COEFF> *, int *);
04103 void (*tabfun2[256])(COEFF *, COEFF*, pol<mon,COEFF> *, int *);
04104 
04105 template <typename T>
04106 void init_pointer()
04107 {
04108 tabfun1[0]=egal0;
04109 tabfun1[1]=egal1;
04110 tabfun1[2]=egal2;
04111 tabfun1[3]=egal3;
04112 tabfun1[4]=egal4;
04113 tabfun1[5]=egal5;
04114 tabfun1[6]=egal6;
04115 tabfun1[7]=egal7;
04116 tabfun1[8]=egal8;
04117 tabfun1[9]=egal9;
04118 tabfun1[10]=egal10;
04119 tabfun1[11]=egal11;
04120 tabfun1[12]=egal12;
04121 tabfun1[13]=egal13;
04122 tabfun1[14]=egal14;
04123 tabfun1[15]=egal15;
04124 tabfun1[16]=egal16;
04125 tabfun1[17]=egal17;
04126 tabfun1[18]=egal18;
04127 tabfun1[19]=egal19;
04128 tabfun1[20]=egal20;
04129 tabfun1[21]=egal21;
04130 tabfun1[22]=egal22;
04131 tabfun1[23]=egal23;
04132 tabfun1[24]=egal24;
04133 tabfun1[25]=egal25;
04134 tabfun1[26]=egal26;
04135 tabfun1[27]=egal27;
04136 tabfun1[28]=egal28;
04137 tabfun1[29]=egal29;
04138 tabfun1[30]=egal30;
04139 tabfun1[31]=egal31;
04140 tabfun1[32]=egal32;
04141 tabfun1[33]=egal33;
04142 tabfun1[34]=egal34;
04143 tabfun1[35]=egal35;
04144 tabfun1[36]=egal36;
04145 tabfun1[37]=egal37;
04146 tabfun1[38]=egal38;
04147 tabfun1[39]=egal39;
04148 tabfun1[40]=egal40;
04149 tabfun1[41]=egal41;
04150 tabfun1[42]=egal42;
04151 tabfun1[43]=egal43;
04152 tabfun1[44]=egal44;
04153 tabfun1[45]=egal45;
04154 tabfun1[46]=egal46;
04155 tabfun1[47]=egal47;
04156 tabfun1[48]=egal48;
04157 tabfun1[49]=egal49;
04158 tabfun1[50]=egal50;
04159 tabfun1[51]=egal51;
04160 tabfun1[52]=egal52;
04161 tabfun1[53]=egal53;
04162 tabfun1[54]=egal54;
04163 tabfun1[55]=egal55;
04164 tabfun1[56]=egal56;
04165 tabfun1[57]=egal57;
04166 tabfun1[58]=egal58;
04167 tabfun1[59]=egal59;
04168 tabfun1[60]=egal60;
04169 tabfun1[61]=egal61;
04170 tabfun1[62]=egal62;
04171 tabfun1[63]=egal63;
04172 tabfun1[64]=egal64;
04173 tabfun1[65]=egal65;
04174 tabfun1[66]=egal66;
04175 tabfun1[67]=egal67;
04176 tabfun1[68]=egal68;
04177 tabfun1[69]=egal69;
04178 tabfun1[70]=egal70;
04179 tabfun1[71]=egal71;
04180 tabfun1[72]=egal72;
04181 tabfun1[73]=egal73;
04182 tabfun1[74]=egal74;
04183 tabfun1[75]=egal75;
04184 tabfun1[76]=egal76;
04185 tabfun1[77]=egal77;
04186 tabfun1[78]=egal78;
04187 tabfun1[79]=egal79;
04188 tabfun1[80]=egal80;
04189 tabfun1[81]=egal81;
04190 tabfun1[82]=egal82;
04191 tabfun1[83]=egal83;
04192 tabfun1[84]=egal84;
04193 tabfun1[85]=egal85;
04194 tabfun1[86]=egal86;
04195 tabfun1[87]=egal87;
04196 tabfun1[88]=egal88;
04197 tabfun1[89]=egal89;
04198 tabfun1[90]=egal90;
04199 tabfun1[91]=egal91;
04200 tabfun1[92]=egal92;
04201 tabfun1[93]=egal93;
04202 tabfun1[94]=egal94;
04203 tabfun1[95]=egal95;
04204 tabfun1[96]=egal96;
04205 tabfun1[97]=egal97;
04206 tabfun1[98]=egal98;
04207 tabfun1[99]=egal99;
04208 tabfun1[100]=egal100;
04209 tabfun1[101]=egal101;
04210 tabfun1[102]=egal102;
04211 tabfun1[103]=egal103;
04212 tabfun1[104]=egal104;
04213 tabfun1[105]=egal105;
04214 tabfun1[106]=egal106;
04215 tabfun1[107]=egal107;
04216 tabfun1[108]=egal108;
04217 tabfun1[109]=egal109;
04218 tabfun1[110]=egal110;
04219 tabfun1[111]=egal111;
04220 tabfun1[112]=egal112;
04221 tabfun1[113]=egal113;
04222 tabfun1[114]=egal114;
04223 tabfun1[115]=egal115;
04224 tabfun1[116]=egal116;
04225 tabfun1[117]=egal117;
04226 tabfun1[118]=egal118;
04227 tabfun1[119]=egal119;
04228 tabfun1[120]=egal120;
04229 tabfun1[121]=egal121;
04230 tabfun1[122]=egal122;
04231 tabfun1[123]=egal123;
04232 tabfun1[124]=egal124;
04233 tabfun1[125]=egal125;
04234 tabfun1[126]=egal126;
04235 tabfun1[127]=egal127;
04236 tabfun1[128]=egal128;
04237 tabfun1[129]=egal129;
04238 tabfun1[130]=egal130;
04239 tabfun1[131]=egal131;
04240 tabfun1[132]=egal132;
04241 tabfun1[133]=egal133;
04242 tabfun1[134]=egal134;
04243 tabfun1[135]=egal135;
04244 tabfun1[136]=egal136;
04245 tabfun1[137]=egal137;
04246 tabfun1[138]=egal138;
04247 tabfun1[139]=egal139;
04248 tabfun1[140]=egal140;
04249 tabfun1[141]=egal141;
04250 tabfun1[142]=egal142;
04251 tabfun1[143]=egal143;
04252 tabfun1[144]=egal144;
04253 tabfun1[145]=egal145;
04254 tabfun1[146]=egal146;
04255 tabfun1[147]=egal147;
04256 tabfun1[148]=egal148;
04257 tabfun1[149]=egal149;
04258 tabfun1[150]=egal150;
04259 tabfun1[151]=egal151;
04260 tabfun1[152]=egal152;
04261 tabfun1[153]=egal153;
04262 tabfun1[154]=egal154;
04263 tabfun1[155]=egal155;
04264 tabfun1[156]=egal156;
04265 tabfun1[157]=egal157;
04266 tabfun1[158]=egal158;
04267 tabfun1[159]=egal159;
04268 tabfun1[160]=egal160;
04269 tabfun1[161]=egal161;
04270 tabfun1[162]=egal162;
04271 tabfun1[163]=egal163;
04272 tabfun1[164]=egal164;
04273 tabfun1[165]=egal165;
04274 tabfun1[166]=egal166;
04275 tabfun1[167]=egal167;
04276 tabfun1[168]=egal168;
04277 tabfun1[169]=egal169;
04278 tabfun1[170]=egal170;
04279 tabfun1[171]=egal171;
04280 tabfun1[172]=egal172;
04281 tabfun1[173]=egal173;
04282 tabfun1[174]=egal174;
04283 tabfun1[175]=egal175;
04284 tabfun1[176]=egal176;
04285 tabfun1[177]=egal177;
04286 tabfun1[178]=egal178;
04287 tabfun1[179]=egal179;
04288 tabfun1[180]=egal180;
04289 tabfun1[181]=egal181;
04290 tabfun1[182]=egal182;
04291 tabfun1[183]=egal183;
04292 tabfun1[184]=egal184;
04293 tabfun1[185]=egal185;
04294 tabfun1[186]=egal186;
04295 tabfun1[187]=egal187;
04296 tabfun1[188]=egal188;
04297 tabfun1[189]=egal189;
04298 tabfun1[190]=egal190;
04299 tabfun1[191]=egal191;
04300 tabfun1[192]=egal192;
04301 tabfun1[193]=egal193;
04302 tabfun1[194]=egal194;
04303 tabfun1[195]=egal195;
04304 tabfun1[196]=egal196;
04305 tabfun1[197]=egal197;
04306 tabfun1[198]=egal198;
04307 tabfun1[199]=egal199;
04308 tabfun1[200]=egal200;
04309 tabfun1[201]=egal201;
04310 tabfun1[202]=egal202;
04311 tabfun1[203]=egal203;
04312 tabfun1[204]=egal204;
04313 tabfun1[205]=egal205;
04314 tabfun1[206]=egal206;
04315 tabfun1[207]=egal207;
04316 tabfun1[208]=egal208;
04317 tabfun1[209]=egal209;
04318 tabfun1[210]=egal210;
04319 tabfun1[211]=egal211;
04320 tabfun1[212]=egal212;
04321 tabfun1[213]=egal213;
04322 tabfun1[214]=egal214;
04323 tabfun1[215]=egal215;
04324 tabfun1[216]=egal216;
04325 tabfun1[217]=egal217;
04326 tabfun1[218]=egal218;
04327 tabfun1[219]=egal219;
04328 tabfun1[220]=egal220;
04329 tabfun1[221]=egal221;
04330 tabfun1[222]=egal222;
04331 tabfun1[223]=egal223;
04332 tabfun1[224]=egal224;
04333 tabfun1[225]=egal225;
04334 tabfun1[226]=egal226;
04335 tabfun1[227]=egal227;
04336 tabfun1[228]=egal228;
04337 tabfun1[229]=egal229;
04338 tabfun1[230]=egal230;
04339 tabfun1[231]=egal231;
04340 tabfun1[232]=egal232;
04341 tabfun1[233]=egal233;
04342 tabfun1[234]=egal234;
04343 tabfun1[235]=egal235;
04344 tabfun1[236]=egal236;
04345 tabfun1[237]=egal237;
04346 tabfun1[238]=egal238;
04347 tabfun1[239]=egal239;
04348 tabfun1[240]=egal240;
04349 tabfun1[241]=egal241;
04350 tabfun1[242]=egal242;
04351 tabfun1[243]=egal243;
04352 tabfun1[244]=egal244;
04353 tabfun1[245]=egal245;
04354 tabfun1[246]=egal246;
04355 tabfun1[247]=egal247;
04356 tabfun1[248]=egal248;
04357 tabfun1[249]=egal249;
04358 tabfun1[250]=egal250;
04359 tabfun1[251]=egal251;
04360 tabfun1[252]=egal252;
04361 tabfun1[253]=egal253;
04362 tabfun1[254]=egal254;
04363 tabfun1[255]=egal255;
04364 
04365 tabfun2[0]=moinsegal0;
04366 tabfun2[1]=moinsegal1;
04367 tabfun2[2]=moinsegal2;
04368 tabfun2[3]=moinsegal3;
04369 tabfun2[4]=moinsegal4;
04370 tabfun2[5]=moinsegal5;
04371 tabfun2[6]=moinsegal6;
04372 tabfun2[7]=moinsegal7;
04373 tabfun2[8]=moinsegal8;
04374 tabfun2[9]=moinsegal9;
04375 tabfun2[10]=moinsegal10;
04376 tabfun2[11]=moinsegal11;
04377 tabfun2[12]=moinsegal12;
04378 tabfun2[13]=moinsegal13;
04379 tabfun2[14]=moinsegal14;
04380 tabfun2[15]=moinsegal15;
04381 tabfun2[16]=moinsegal16;
04382 tabfun2[17]=moinsegal17;
04383 tabfun2[18]=moinsegal18;
04384 tabfun2[19]=moinsegal19;
04385 tabfun2[20]=moinsegal20;
04386 tabfun2[21]=moinsegal21;
04387 tabfun2[22]=moinsegal22;
04388 tabfun2[23]=moinsegal23;
04389 tabfun2[24]=moinsegal24;
04390 tabfun2[25]=moinsegal25;
04391 tabfun2[26]=moinsegal26;
04392 tabfun2[27]=moinsegal27;
04393 tabfun2[28]=moinsegal28;
04394 tabfun2[29]=moinsegal29;
04395 tabfun2[30]=moinsegal30;
04396 tabfun2[31]=moinsegal31;
04397 tabfun2[32]=moinsegal32;
04398 tabfun2[33]=moinsegal33;
04399 tabfun2[34]=moinsegal34;
04400 tabfun2[35]=moinsegal35;
04401 tabfun2[36]=moinsegal36;
04402 tabfun2[37]=moinsegal37;
04403 tabfun2[38]=moinsegal38;
04404 tabfun2[39]=moinsegal39;
04405 tabfun2[40]=moinsegal40;
04406 tabfun2[41]=moinsegal41;
04407 tabfun2[42]=moinsegal42;
04408 tabfun2[43]=moinsegal43;
04409 tabfun2[44]=moinsegal44;
04410 tabfun2[45]=moinsegal45;
04411 tabfun2[46]=moinsegal46;
04412 tabfun2[47]=moinsegal47;
04413 tabfun2[48]=moinsegal48;
04414 tabfun2[49]=moinsegal49;
04415 tabfun2[50]=moinsegal50;
04416 tabfun2[51]=moinsegal51;
04417 tabfun2[52]=moinsegal52;
04418 tabfun2[53]=moinsegal53;
04419 tabfun2[54]=moinsegal54;
04420 tabfun2[55]=moinsegal55;
04421 tabfun2[56]=moinsegal56;
04422 tabfun2[57]=moinsegal57;
04423 tabfun2[58]=moinsegal58;
04424 tabfun2[59]=moinsegal59;
04425 tabfun2[60]=moinsegal60;
04426 tabfun2[61]=moinsegal61;
04427 tabfun2[62]=moinsegal62;
04428 tabfun2[63]=moinsegal63;
04429 tabfun2[64]=moinsegal64;
04430 tabfun2[65]=moinsegal65;
04431 tabfun2[66]=moinsegal66;
04432 tabfun2[67]=moinsegal67;
04433 tabfun2[68]=moinsegal68;
04434 tabfun2[69]=moinsegal69;
04435 tabfun2[70]=moinsegal70;
04436 tabfun2[71]=moinsegal71;
04437 tabfun2[72]=moinsegal72;
04438 tabfun2[73]=moinsegal73;
04439 tabfun2[74]=moinsegal74;
04440 tabfun2[75]=moinsegal75;
04441 tabfun2[76]=moinsegal76;
04442 tabfun2[77]=moinsegal77;
04443 tabfun2[78]=moinsegal78;
04444 tabfun2[79]=moinsegal79;
04445 tabfun2[80]=moinsegal80;
04446 tabfun2[81]=moinsegal81;
04447 tabfun2[82]=moinsegal82;
04448 tabfun2[83]=moinsegal83;
04449 tabfun2[84]=moinsegal84;
04450 tabfun2[85]=moinsegal85;
04451 tabfun2[86]=moinsegal86;
04452 tabfun2[87]=moinsegal87;
04453 tabfun2[88]=moinsegal88;
04454 tabfun2[89]=moinsegal89;
04455 tabfun2[90]=moinsegal90;
04456 tabfun2[91]=moinsegal91;
04457 tabfun2[92]=moinsegal92;
04458 tabfun2[93]=moinsegal93;
04459 tabfun2[94]=moinsegal94;
04460 tabfun2[95]=moinsegal95;
04461 tabfun2[96]=moinsegal96;
04462 tabfun2[97]=moinsegal97;
04463 tabfun2[98]=moinsegal98;
04464 tabfun2[99]=moinsegal99;
04465 tabfun2[100]=moinsegal100;
04466 tabfun2[101]=moinsegal101;
04467 tabfun2[102]=moinsegal102;
04468 tabfun2[103]=moinsegal103;
04469 tabfun2[104]=moinsegal104;
04470 tabfun2[105]=moinsegal105;
04471 tabfun2[106]=moinsegal106;
04472 tabfun2[107]=moinsegal107;
04473 tabfun2[108]=moinsegal108;
04474 tabfun2[109]=moinsegal109;
04475 tabfun2[110]=moinsegal110;
04476 tabfun2[111]=moinsegal111;
04477 tabfun2[112]=moinsegal112;
04478 tabfun2[113]=moinsegal113;
04479 tabfun2[114]=moinsegal114;
04480 tabfun2[115]=moinsegal115;
04481 tabfun2[116]=moinsegal116;
04482 tabfun2[117]=moinsegal117;
04483 tabfun2[118]=moinsegal118;
04484 tabfun2[119]=moinsegal119;
04485 tabfun2[120]=moinsegal120;
04486 tabfun2[121]=moinsegal121;
04487 tabfun2[122]=moinsegal122;
04488 tabfun2[123]=moinsegal123;
04489 tabfun2[124]=moinsegal124;
04490 tabfun2[125]=moinsegal125;
04491 tabfun2[126]=moinsegal126;
04492 tabfun2[127]=moinsegal127;
04493 tabfun2[128]=moinsegal128;
04494 tabfun2[129]=moinsegal129;
04495 tabfun2[130]=moinsegal130;
04496 tabfun2[131]=moinsegal131;
04497 tabfun2[132]=moinsegal132;
04498 tabfun2[133]=moinsegal133;
04499 tabfun2[134]=moinsegal134;
04500 tabfun2[135]=moinsegal135;
04501 tabfun2[136]=moinsegal136;
04502 tabfun2[137]=moinsegal137;
04503 tabfun2[138]=moinsegal138;
04504 tabfun2[139]=moinsegal139;
04505 tabfun2[140]=moinsegal140;
04506 tabfun2[141]=moinsegal141;
04507 tabfun2[142]=moinsegal142;
04508 tabfun2[143]=moinsegal143;
04509 tabfun2[144]=moinsegal144;
04510 tabfun2[145]=moinsegal145;
04511 tabfun2[146]=moinsegal146;
04512 tabfun2[147]=moinsegal147;
04513 tabfun2[148]=moinsegal148;
04514 tabfun2[149]=moinsegal149;
04515 tabfun2[150]=moinsegal150;
04516 tabfun2[151]=moinsegal151;
04517 tabfun2[152]=moinsegal152;
04518 tabfun2[153]=moinsegal153;
04519 tabfun2[154]=moinsegal154;
04520 tabfun2[155]=moinsegal155;
04521 tabfun2[156]=moinsegal156;
04522 tabfun2[157]=moinsegal157;
04523 tabfun2[158]=moinsegal158;
04524 tabfun2[159]=moinsegal159;
04525 tabfun2[160]=moinsegal160;
04526 tabfun2[161]=moinsegal161;
04527 tabfun2[162]=moinsegal162;
04528 tabfun2[163]=moinsegal163;
04529 tabfun2[164]=moinsegal164;
04530 tabfun2[165]=moinsegal165;
04531 tabfun2[166]=moinsegal166;
04532 tabfun2[167]=moinsegal167;
04533 tabfun2[168]=moinsegal168;
04534 tabfun2[169]=moinsegal169;
04535 tabfun2[170]=moinsegal170;
04536 tabfun2[171]=moinsegal171;
04537 tabfun2[172]=moinsegal172;
04538 tabfun2[173]=moinsegal173;
04539 tabfun2[174]=moinsegal174;
04540 tabfun2[175]=moinsegal175;
04541 tabfun2[176]=moinsegal176;
04542 tabfun2[177]=moinsegal177;
04543 tabfun2[178]=moinsegal178;
04544 tabfun2[179]=moinsegal179;
04545 tabfun2[180]=moinsegal180;
04546 tabfun2[181]=moinsegal181;
04547 tabfun2[182]=moinsegal182;
04548 tabfun2[183]=moinsegal183;
04549 tabfun2[184]=moinsegal184;
04550 tabfun2[185]=moinsegal185;
04551 tabfun2[186]=moinsegal186;
04552 tabfun2[187]=moinsegal187;
04553 tabfun2[188]=moinsegal188;
04554 tabfun2[189]=moinsegal189;
04555 tabfun2[190]=moinsegal190;
04556 tabfun2[191]=moinsegal191;
04557 tabfun2[192]=moinsegal192;
04558 tabfun2[193]=moinsegal193;
04559 tabfun2[194]=moinsegal194;
04560 tabfun2[195]=moinsegal195;
04561 tabfun2[196]=moinsegal196;
04562 tabfun2[197]=moinsegal197;
04563 tabfun2[198]=moinsegal198;
04564 tabfun2[199]=moinsegal199;
04565 tabfun2[200]=moinsegal200;
04566 tabfun2[201]=moinsegal201;
04567 tabfun2[202]=moinsegal202;
04568 tabfun2[203]=moinsegal203;
04569 tabfun2[204]=moinsegal204;
04570 tabfun2[205]=moinsegal205;
04571 tabfun2[206]=moinsegal206;
04572 tabfun2[207]=moinsegal207;
04573 tabfun2[208]=moinsegal208;
04574 tabfun2[209]=moinsegal209;
04575 tabfun2[210]=moinsegal210;
04576 tabfun2[211]=moinsegal211;
04577 tabfun2[212]=moinsegal212;
04578 tabfun2[213]=moinsegal213;
04579 tabfun2[214]=moinsegal214;
04580 tabfun2[215]=moinsegal215;
04581 tabfun2[216]=moinsegal216;
04582 tabfun2[217]=moinsegal217;
04583 tabfun2[218]=moinsegal218;
04584 tabfun2[219]=moinsegal219;
04585 tabfun2[220]=moinsegal220;
04586 tabfun2[221]=moinsegal221;
04587 tabfun2[222]=moinsegal222;
04588 tabfun2[223]=moinsegal223;
04589 tabfun2[224]=moinsegal224;
04590 tabfun2[225]=moinsegal225;
04591 tabfun2[226]=moinsegal226;
04592 tabfun2[227]=moinsegal227;
04593 tabfun2[228]=moinsegal228;
04594 tabfun2[229]=moinsegal229;
04595 tabfun2[230]=moinsegal230;
04596 tabfun2[231]=moinsegal231;
04597 tabfun2[232]=moinsegal232;
04598 tabfun2[233]=moinsegal233;
04599 tabfun2[234]=moinsegal234;
04600 tabfun2[235]=moinsegal235;
04601 tabfun2[236]=moinsegal236;
04602 tabfun2[237]=moinsegal237;
04603 tabfun2[238]=moinsegal238;
04604 tabfun2[239]=moinsegal239;
04605 tabfun2[240]=moinsegal240;
04606 tabfun2[241]=moinsegal241;
04607 tabfun2[242]=moinsegal242;
04608 tabfun2[243]=moinsegal243;
04609 tabfun2[244]=moinsegal244;
04610 tabfun2[245]=moinsegal245;
04611 tabfun2[246]=moinsegal246;
04612 tabfun2[247]=moinsegal247;
04613 tabfun2[248]=moinsegal248;
04614 tabfun2[249]=moinsegal249;
04615 tabfun2[250]=moinsegal250;
04616 tabfun2[251]=moinsegal251;
04617 tabfun2[252]=moinsegal252;
04618 tabfun2[253]=moinsegal253;
04619 tabfun2[254]=moinsegal254;
04620 tabfun2[255]=moinsegal255;
04621 }
04622 
04623 #endif