1 // Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 // SuperVisionTest SyrComponent : example of component performing some mathinatical operations
24 // File : SyrComponent_CheckOfUndefined.cxx
25 // Module : SuperVisionTest
40 // ------------------------------------------------------------------
41 // NextPrime : Compute the first prime number greater or equal than an integer
42 // ------------------------------------------------------------------
46 long NextPrime (const long me )
49 struct svalue {int signiaib ;
52 struct svalue values[VALUESNBR] ;
57 // int signiaib[4] = { -1 , +1 , +1 , -1 } ;
79 // Standard_RangeError::
80 // Raise("Try to apply NextPrime method with negative, null or too large value.");
97 minn = ( me - 1 ) / 6 ; // n minimum
98 while ( 6*minn+1 < me ) {
102 maxia = long( sqrt( (double)me ) / 6 + 1 ) ;
104 maxvn = minn + VALUESNBR ;
107 for ( nindd = 0 ; nindd < VALUESNBR ; nindd++ ) {
108 if ( 6*(nindd+minn)-1 < me ) {
109 values[nindd].nbr = 1 ;
110 values[nindd].signiaib = -1 ;
114 values[nindd].nbr = 0 ;
115 values[nindd].signiaib = 0 ;
119 for ( ia = 1 ; ia <= maxia ; ia++ ) {
120 if ( nbvalues == VALUESNBR*2 ) {
123 remain = -VALUESNBR ;
124 ib[0] = ( minn + ia - remain ) / (6*ia - 1) ;
125 n[0] = int ( 6*ia*ib[0] - ia - ib[0] - minn ) ;
126 ib[1] = ( minn - ia - remain ) / (6*ia - 1) ;
127 n[1] = int ( 6*ia*ib[1] + ia - ib[1] - minn ) ;
128 ib[2] = ( minn + ia - remain ) / (6*ia + 1) ;
129 n[2] = int ( 6*ia*ib[2] - ia + ib[2] - minn ) ;
130 ib[3] = ( minn - ia - remain ) / (6*ia + 1) ;
131 n[3] = int ( 6*ia*ib[3] + ia + ib[3] - minn ) ;
132 for ( loop = 0 ; loop < 4 ; loop++ ) {
133 if ( n[loop] >= 0 && n[loop] < VALUESNBR ) {
134 if ( ( values[n[loop]].nbr == 0 ) ||
135 ( values[n[loop]].signiaib == signiaib[loop] ) ) {
136 values[n[loop]].signiaib = -signiaib[loop] ;
137 values[n[loop]].nbr += 1 ;
138 if ( values[n[loop]].nbr <= 2 )
144 for ( nindd = 0 ; nindd < VALUESNBR ; nindd++ ) {
145 if ( values[nindd].nbr == 0 ) {
146 if ( me <= 6*(nindd+minn)-1 ) {
147 premret = 6*(nindd+minn)-1 ;
150 else if ( me <= 6*(nindd+minn)+1 ) {
151 premret = 6*(nindd+minn)+1 ;
155 else if ( values[nindd].nbr == 1 ) {
156 if ( values[nindd].signiaib > 0 ) {
157 if ( me <= 6*(nindd+minn)-1 ) {
158 premret = 6*(nindd+minn)-1 ;
163 if ( me <= 6*(nindd+minn)+1 ) {
164 premret = 6*(nindd+minn)+1 ;
171 if ( premret != 0 ) {
175 return NextPrime ( 6*(maxvn-1)+2) ;
179 static char * base( int b , long n ) {
188 sprintf( ccc ,"%d" , ( n % b ) ) ;
198 static char * B2( long n ) {
199 return base( 2 , n ) ;
202 static char * B3( long n ) {
203 return base( 3 , n ) ;
206 static char * B4( long n ) {
207 return base( 4 , n ) ;
210 static char * B5( long n ) {
211 return base( 5 , n ) ;
214 static char * B7( long n ) {
215 return base( 7 , n ) ;
218 static char * B8( long n ) {
219 return base( 8 , n ) ;
222 static long S( long f , long n ) {
225 for ( i = 0 ; i <= n ; i++ ) {
231 static long S2( long n ) {
235 static long S6( long n ) {
239 static long rP( long odd ) {
240 if ( (( odd - 1 ) % 6 ) == 0 )
242 if ( (( odd - 3 ) % 6 ) == 0 )
244 if ( (( odd - 5 ) % 6 ) == 0 )
248 static long nP( long odd ) {
252 static long rQ( long N ) {
253 if ( ( N & 7 ) == 5 ) {
258 static long nQ( long N ) {
259 if ( ( N & 3 ) == 3 ) {
267 static long rT( long N ) {
268 return ( nP( N ) % 3 ) ;
270 static long nT( long N ) {
271 return ( nP( N ) / 3 ) ;
274 static char * fact( int n ) {
275 static char chn[132] ;
277 strcpy( chn , "0" ) ;
280 strcpy( chn , "1" ) ;
285 while ( (n & 1 ) == 0 ) {
289 while ( ( n % 3 ) == 0 ) {
296 sprintf( &chn[pos] , "%d" , 2 ) ;
299 sprintf( &chn[pos] , "2**%d" , pow2 ) ;
301 pos = strlen( chn ) ;
305 strcat( chn , "*" ) ;
306 pos = strlen( chn ) ;
309 sprintf( &chn[pos] , "%d" , 3 ) ;
312 sprintf( &chn[pos] , "3**%d" , pow3 ) ;
314 pos = strlen( chn ) ;
317 if ( pow2 || pow3 ) {
318 sprintf( &chn[pos] , "*%d" , n ) ;
321 sprintf( &chn[pos] , "%d" , n ) ;
328 static long Next( const long prev , long &pow2 ) {
329 long next = ( 3*prev + 1 )/2 ;
331 while ( ( next & 1 ) == 0 ) {
332 next = ( next >> 1 ) ;
338 int T1a( int n0 , int n1 ) {
339 return (1<<(6*n1+2))*(3*n0+0) + (1<<(6*n1+1)) + S2(3*n1+0) ;
341 int T1b( int n0 , int n1 ) {
342 return (1<<(6*n1+6))*(3*n0+1) + (1<<(6*n1+5)) + S2(3*n1+2) ;
344 int T1c( int n0 , int n1 ) {
345 return (1<<(6*n1+4))*(3*n0+2) + (1<<(6*n1+3)) + S2(3*n1+1) ;
347 int T2a( int n0 , int n1 ) {
348 return (1<<(6*n1+7))*(3*n0+0) + S2(3*n1+2) ;
350 int T2b( int n0 , int n1 ) {
351 return (1<<(6*n1+3))*(3*n0+1) + S2(3*n1+0) ;
353 int T2c( int n0 , int n1 ) {
354 return (1<<(6*n1+5))*(3*n0+2) + S2(3*n1+1) ;
357 int P1a1( int n0 , int n1 ) {
358 return (1<<(6*n1+4))*(3*n0+0) + (1<<(6*n1+3)) + S2(3*n1+1) ;
360 int P1a2( int n0 , int n1 ) {
361 return (1<<(6*n1+6))*(3*n0+0) + (1<<(6*n1+5)) + S2(3*n1+2) ;
363 int P1b1( int n0 , int n1 ) {
364 return (1<<(6*n1+2))*(3*n0+1) + (1<<(6*n1+1)) + S2(3*n1+0) ;
366 int P1b2( int n0 , int n1 ) {
367 return (1<<(6*n1+4))*(3*n0+1) + (1<<(6*n1+3)) + S2(3*n1+1) ;
369 int P1c1( int n0 , int n1 ) {
370 return (1<<(6*n1+2))*(3*n0+2) + (1<<(6*n1+1)) + S2(3*n1+0) ;
372 int P1c2( int n0 , int n1 ) {
373 return (1<<(6*n1+6))*(3*n0+2) + (1<<(6*n1+5)) + S2(3*n1+2) ;
376 int P2a1( int n0 , int n1 ) {
377 return (1<<(6*n1+3))*(3*n0+0) + S2(3*n1+0) ;
379 int P2a2( int n0 , int n1 ) {
380 return (1<<(6*n1+5))*(3*n0+0) + S2(3*n1+1) ;
382 int P2b1( int n0 , int n1 ) {
383 return (1<<(6*n1+5))*(3*n0+1) + S2(3*n1+1) ;
385 int P2b2( int n0 , int n1 ) {
386 return (1<<(6*n1+7))*(3*n0+1) + S2(3*n1+2) ;
388 int P2c1( int n0 , int n1 ) {
389 return (1<<(6*n1+3))*(3*n0+2) + S2(3*n1+0) ;
391 int P2c2( int n0 , int n1 ) {
392 return (1<<(6*n1+7))*(3*n0+2) + S2(3*n1+2) ;
395 typedef int (*fct)(int,int);
399 void Compute( char * fctname , fct afct , int PT , int PP , int PPNext ) {
404 for ( n1 = 0 ; n1 <= 3 ; n1++ ) {
406 for ( n0 = 0 ; n0 <= 500 && value < 3000 ; n0++ ) {
407 value = afct( n0 , n1 ) ;
409 next = Next( value , pow2 ) ;
411 if ( ( rP( value ) == 3 && rP( Next( next , kp2 ) ) == PPNext ) ||
412 ( rT( value ) == PT && rP( value ) == PP &&
413 rP( next ) == PPNext ) ) {
414 if ( rQ( value ) == 3 ||
415 ( rQ( value ) == 1 && ( nQ( value ) & 1 ) == 0 ) ) {
417 // *_Trace << " n1 " << n1 ;
418 // *_Trace << " n0 " << n0 << " " ;
424 else if ( value < 100 )
426 else if ( value < 1000 )
428 *_Trace << value << " " ;
429 long lownext = (next-1)/4 ;
430 if ( 4*lownext+1 == next && ( lownext & 1 ) == 1 ) {
433 *_Trace << fctname << " n0 " << n0 << " " ;
435 *_Trace << value << " = 6[3*" << nT( value ) << "+"
436 << rT( value ) << "]+" << rP( value ) << " --> "
437 << next << " (>>" << pow2 << ") = 6[3*"
438 << nT( next ) << "+" << rT( next )
439 << "] + " << rP( next ) << endl ;
444 *_Trace << " n1 " << n1 ;
445 *_Trace << " n0 " << n0 << " " ;
449 *_Trace << " n0 " << n0 << " " ;
451 *_Trace << "---" << value << " = 6[3*" << nT( value ) << "+"
452 << rT( value ) << "]+" << rP( value ) << " = 4*["
453 << "2*" << nQ( value )/2 << "+1]+1" ;
454 if ( Next( (value-1)/4 , kp2 ) != next )
455 *_Trace << " " << Next( (value-1)/4 , kp2 ) << " != " << next ;
465 int SeqSyr( int n ) {
474 *_Trace << " " << n ;
476 n = Next( n , pow2 ) ;
487 if ( ( nstep % 2 ) == 0 ) {
488 *_Trace << endl << " " ;
492 *_Trace << " -> " << n << " = " << EQ << "*" << q << "+" << r
493 << " = 6*" << Sq << "+" << Sr ;
499 if ( r == 5 && q > nn/8 ) {
505 void little( int depth , int prt , int n , int r ) {
515 *_Trace << endl << depth << " little2 n = " << n << " r = " << r << endl ;
519 if ( ( r0 % 3 ) == 0 ) {
521 if ( depth == prt ) {
522 *_Trace << "n->3n " << n0 << "n + " << r1 << " = 4[ "
523 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
527 else if ( ( ( n0 + r0 ) % 3 ) == 0 ) {
528 r1 = ( n0 + r0 ) / 3 ;
529 if ( depth == prt ) {
530 *_Trace << "n->3n+1 " << n0 << "n + " << r1 << " = 4[ "
531 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
535 else if ( ( ( 2*n0 + r0 ) % 3 ) == 0 ) {
536 r1 = ( 2*n0 + r0 ) / 3 ;
537 if ( depth == prt ) {
538 *_Trace << "n->3n+2 " << n0 << "n + " << r1 << " = 4[ "
539 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
545 *_Trace << endl << depth << " little4 n = " << n << " r = " << r << endl ;
549 if ( ( r2 % 3 ) == 0 ) {
551 if ( depth == prt ) {
552 *_Trace << "n->3n " << n1 << "n + " << r2 << " = 8[ "
553 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
557 else if ( ( ( n1 + r2 ) % 3 ) == 0 ) {
558 r2 = ( n1 + r2 ) / 3 ;
559 if ( depth == prt ) {
560 *_Trace << "n->3n+1 " << n1 << "n + " << r2 << " = 8[ "
561 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
565 else if ( ( ( 2*n1 + r2 ) % 3 ) == 0 ) {
566 r2 = ( 2*n1 + r2 ) / 3 ;
567 if ( depth == prt ) {
568 *_Trace << "n->3n+2 " << n1 << "n + " << r2 << " = 8[ "
569 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
575 little( depth , prt , n0 , r1 ) ;
576 little( depth , prt , n1 , r2 ) ;
581 int main(int argc, char **argv) {
593 _Trace = new ofstream( "/cas_01/jr/linux/SyrP.log" );
595 for ( l = 0 ; l <= 17 ; l++ ) {
596 for ( l1 = -1 ; l1 <= 1 ; l1 += 2 ) {
598 if ( P > 0 && NextPrime( P-1 ) == P ) {
599 for ( k = -1 ; k <= 1 ; k += 2 ) {
600 for ( i = 1 ; i <= 30 ; i++ ) {
601 for ( j = 1 ; j <= 30 ; j++ ) {
602 n = int( pow( (double)2 , (double)i ) * pow( (double)3 , (double)j )*P ) + k ;
603 if ( n < 0 || n > pow( (double)2 , (double)30 ) ) {
606 if ( NextPrime( n-1 ) == n ) {
607 *_Trace << n << " = 2**" << i << " * 3**" << j << " * " << P << " + "
611 if ( NextPrime( n-1 ) != n && ( n % P ) == 0 ) {
612 *_Trace << n << " = 2**" << i << " * 3**" << j << " * " << P << " + "
616 while ( ( n % p ) == 0 ) {
617 *_Trace << p << "*" ;
620 p = NextPrime( p + 1 ) ;
622 *_Trace << n << endl ;
635 _Trace = new ofstream( "/cas_01/jr/linux/Syr.log" );
641 for ( prt = 1 ; prt <= 5 ; prt++ ) {
642 *_Trace << endl << prt << ". 8n + 1 :" << endl ;
643 little( 0 , prt , 8 , 1 ) ;
646 for ( prt = 1 ; prt <= 5 ; prt++ ) {
647 *_Trace << endl << prt << ". 4n + 3 :" << endl ;
648 little( 0 , prt , 4 , 3 ) ;
651 for ( prt = 1 ; prt <= 6 ; prt++ ) {
652 *_Trace << endl << prt << ". 8n + 5 :" << endl ;
653 little( 0 , prt , 8 , 5 ) ;
659 for ( i = 0 ; i <= max ; i++ ) {
660 *_Trace << endl << endl << "8*" << i << "+5 = 4[2*" << i << "+1]+1 = " ;
662 while ( ((ii-1) & 7) == 4 ) {
663 *_Trace << endl << " 8*" << ii/8 << "+5 = 4[2*" << ii/4
667 *_Trace << "6*" << nP(8*i + 5) << "+" << rP(8*i + 5) << " :" << endl ;
668 n = SeqSyr( 8*i + 5 ) ;
670 while ( n && n > max ) {
671 *_Trace << endl << " ==> 8*" << n << "+5 = 4[2*" << n << "+1]+1 = " ;
673 while ( ((ii-1) & 7) == 4 ) {
674 *_Trace << endl << "8*" << ii/8 << "+5 = 4[2*" << ii/4 << "+1]+1 = " ;
677 *_Trace << "6*" << nP(8*n + 5) << "+" << rP(8*n + 5) << " :" << endl ;
678 n = SeqSyr( 8*n + 5 ) ;
697 *_Trace << "2**[x(n+1)] = (2**x-1)*S[x](n)+1" << endl << endl ;
699 *_Trace << "2**[(2x+1)(2n+rn+1)] = (2**(2x+1)-1)*S[2x+1](2n+rn)+1" << endl ;
700 *_Trace << " = 2**(2x+1){(2**(2x+1)-1)*S[2x+1](2n+rn)-1}"
702 *_Trace << "2**[2x(3n+rn+1)] = (2**2x-1)*S[2x](3n+rn)+1" << endl ;
703 *_Trace << " = 2**2x{(2**2x-1)*S[2x](3n+rn-1)-1}"
705 *_Trace << "2**(2x+1)-1 = 6S2(x-1)+1" << endl << endl ;
707 *_Trace << "2**(2(3x+1))-1 = 3(6*2*7*S6(x-1)+1) *4 :" << endl ;
708 *_Trace << "2**(2(3x+2))-1 = 3(6*2**3*7*S6(x-1)+5) *4 :" << endl ;
709 *_Trace << "2**(2(3x+3))-1 = 3(6*2**5*7*S6(x-1)+21)" << endl ;
710 *_Trace << " = 3**2(2**6*7*S6(x-1)+7)" << endl ;
711 *_Trace << " = 3**2*7(2**6*S6(x-1)+1)" << endl ;
712 *_Trace << " = 3**2*7*S6(x)" << endl ;
713 *_Trace << "2**(2(3x))-1 = 3**2*7*S6(x-1)" << endl ;
714 *_Trace << "2**(2(3x+4))-1 = 3(6*2*7*S6(x)+1) *4 :" << endl ;
715 *_Trace << "2**(2(3x+5))-1 = 3(6*2**3*7*S6(x)+5)" << endl << endl ;
716 *_Trace << "2**(2(3x+rx))-1 = 3**2*2**(2rx)*7*S6(x-1)+2**(2rx)-1" << endl
719 *_Trace << "2**[(2x+1)(2n+rn+1)] = (6S2(x-1)+1)*S[2x+1](2n+rn)+1" << endl ;
720 *_Trace << "2**[2(3x+rx)(3n+rn+1)] = {3**2*2**(2rx)*7*S6(x-1)+2**(2rx)-1}*"
721 << endl << " S[2(3x+rx)](3n+rn)+1" << endl
724 *_Trace << "(6x+5)y+x = 2**3*7*S6(x-1)" << endl ;
725 *_Trace << "x = 0 ; y = 0" << endl ;
726 *_Trace << "x = 1 ; y = 5" << endl ;
727 *_Trace << "x = 2 ; y = 214 = 2*107 = 2*O153" << endl ;
728 *_Trace << "x = 3 ; y = 10131 = 3*3377 = 3*O6461" << endl ;
729 *_Trace << "x = 4 ; y = 514244 = 4*128561 = 4*O373061" << endl ;
730 *_Trace << "x = 5 ; y = ?" << endl ;
731 *_Trace << "x = 6 ; y = 1489853154 = 6*248308859 = 6*O1663162173" << endl
734 for ( pow = 1 ; pow <= 31 ; pow++ ) {
736 for ( x = 0 ; x <= 30 ; x++ ) {
737 for ( n = 0 ; n <= 30 ; n++ ) {
738 for ( rn = 0 ; rn <= 1 ; rn++ ) {
739 if ( (2*x+1)*(2*n+rn+1) == pow && (2*x+1)*(2*n+rn+1) <= 31 ) {
740 int val = (1 << (2*x+1)*(2*n+rn+1)) ;
741 *_Trace << "2**(" << 2*x+1 << "*(" << 2*n+rn << "+1)) = " ;
742 *_Trace << "2**[(2*" << x << "+1)(2*" << n << "+" << rn
746 while ( SIG && (SIG % 3) == 0 ) {
750 *_Trace << "3**" << pow3 << "*" << SIG
751 << "+1) * " << fact( S(2*x+1,2*n+rn) )
753 << " (6*S2(" << x-1 << ")+1)*S" << 2*x+1 << "("
754 << 2*n+rn << ")+1 = "
755 << "(6*S2(" << x << "-1)+1)*S[2*" << x << "+1](2*"
756 << n << "+" << rn << ")+1 = " << val << endl ;
757 if ( val != (6*S(2,x-1)+1)*S(2*x+1,2*n+rn)+1 ) {
758 *_Trace << val << " != " << (6*S(2,x-1)+1)*S(2*x+1,2*n+rn)+1
765 for ( x = 0 ; x <= 30 ; x++ ) {
766 for ( rx = 0 ; rx <= 2 ; rx++ ) {
767 for ( n = 0 ; n <= 30 ; n++ ) {
768 for ( rn = 0 ; rn <= 2 ; rn++ ) {
769 if ( 3*x+rx != 0 && 2*(3*x+rx)*(3*n+rn+1) == pow
770 && 2*(3*x+rx)*(3*n+rn+1) <= 31 ) {
771 *_Trace << "2**[" << 2*(3*x+rx) << "*(" << 3*n+rn << "+1)] = " ;
772 *_Trace << "2**[2(3*" << x << "+" << rx << ")(3*" << n << "+"
773 << rn << "+1)] = [9*" << (1 << (2*rx)) << "*7*"
775 int DRX = (1 << (2*rx))-1 ;
777 while ( DRX && (DRX % 3) == 0 ) {
781 *_Trace << "3**" << pow3 << "*" << DRX << "] * " ;
782 int SIG = S(2*(3*x+rx),3*n+rn) ;
784 while ( SIG && (SIG % 3) == 0 ) {
788 *_Trace << "3**" << pow3 << "*" << fact( SIG )
790 << " [3**2*2**" << 2*rx << "*7*S6("
791 << x << "-1)+" << (1 << (2*rx))-1 << "] * S"
792 << 2*(3*x+rx) << "(" << 3*n+rn << ")+1 = " << endl
793 << " {3**2*2**(2*" << rx << ")*7*S6("
794 << x << "-1)+2**(2*" << rx << ")-1} * S[2(3*"
795 << x << "+" << rx << ")](3*" << n << "+" << rn << ")+1"
797 int val = (1 << (2*(3*x+rx)*(3*n+rn+1)) ) ;
798 if ( val != (3*3*(1<<(2*rx))*7*S(6,x-1)+(1<<(2*rx))-1)*S(2*(3*x+rx),3*n+rn)+1 ) {
799 *_Trace << val << " != " << (3*3*(1<<(2*rx))*7*S(6,x-1)+(1<<(2*rx))-1) * S(2*(3*x+rx),3*n+rn)+1 << endl ;
811 for ( x = 1 ; x <= 30 ; x++ ) {
812 for ( n = 0 ; n <= 30 ; n++ ) {
813 if ( x*(n+1) <= 30 ) {
814 X = ((1 << x ) - 1)*S(x,n) + 1 ;
815 if ( (1 << (x*(n+1)) ) == X ) {
816 *_Trace << "2**[" << x << "(" << n << "+1)] = 2**[[" ;
821 while ( p && (p & 1) == 0 ) {
825 while ( p && (p % 3) == 0 ) {
832 *_Trace << "**" << pow2 ;
834 if ( pow3 || p != 1 ) {
841 *_Trace << "**" << pow3 ;
847 if ( !((pow2 || pow3) && p == 1) ) {
854 while ( p && (p & 1) == 0 ) {
858 while ( p && (p % 3) == 0 ) {
865 *_Trace << "**" << pow2 ;
867 if ( pow3 || p != 1 ) {
874 *_Trace << "**" << pow3 ;
880 if ( !((pow2 || pow3) && p == 1) ) {
884 int d = (1 << x) - 1 ;
886 while ( (d % 3) == 0 ) {
890 *_Trace << " = (2**" << x << "-1)*S" ;
892 *_Trace << x << "[2*" << n/2 ;
896 *_Trace << "]+1 = " ;
899 *_Trace << x << "[3*" << n/3 << "+" << (n % 3) << "]+1 = " ;
905 *_Trace << "**" << pow3 ;
916 *_Trace << "[6*" << nP(d) << "+" << rP(d) << "]" ;
919 *_Trace << "[" << rP(d) << "]" ;
925 while ( (Y % 2) == 0 ) {
930 while ( (Y % 3) == 0 ) {
937 *_Trace << "**" << pow2 ;
944 *_Trace << "**" << pow3 ;
948 if ( nP(Y) && ( (nP(Y) & 1) == 0 || (nP(Y) % 3) == 0 ) ) {
952 while ( (YY % 2) == 0 ) {
957 while ( (YY % 3) == 0 ) {
964 *_Trace << "**" << pow2 ;
971 *_Trace << "**" << pow3 ;
975 *_Trace << YY << "+" << rP(Y) << "]}+1" << endl ;
979 *_Trace << "[6*" << nP(Y) << "+" << rP(Y) << "]}+1" << endl ;
982 *_Trace << "[" << rP(Y) << "]}+1" << endl ;
987 *_Trace << endl << (1 << (x*(n+1)) ) << " = 2**[" << x << "(" << n
988 << "+1)] != " << X << "(2**" << x
989 << "-1)*S" << x << "[" << n << "]+1" << endl ;
996 *_Trace << "S[x]( n ) = Sigma((2**x)*i) i = 0 , n" << endl ;
997 *_Trace << "S[x]( aq + r ) = X*S[a*x]( q - 1 ) + Sx( r )" << endl ;
998 for ( x = 2 ; x <= 10 ; x++ ) {
999 *_Trace << endl << endl ;
1000 for ( a = 2 ; a <= 12 ; a++ ) {
1002 for ( q = 1 ; q <= 12 ; q++ ) {
1003 for ( r = 0 ; r < a ; r++ ) {
1004 if ( a*q + r <= 24 ) {
1005 int i = S( x , a*q+r ) - S( x , r ) ;
1006 int X = i / S( a*x , q-1 ) ;
1008 if ( X*S( a*x , q-1 ) == i && (i % S( a*x , q-1 ) ) == 0 ) {
1009 while ( ( X & 1 ) == 0 ) {
1014 while ( X > 0 && ( X % 3 ) == 0 ) {
1018 *_Trace << "S( " << x << " , " << a << "*" << q << " + " << r
1019 << " ) = 2**" << p2 << "*3**" << p3 << "*"<< X
1020 << "*S[" << a << "*" << x << "]( " << q << "-1 ) + S( "
1021 << x << " , " << r << " )" << endl ;
1033 for ( PP = 1 ; PP <= 5 ; PP+=4 ) {
1034 for ( PPNext = 1 ; PPNext <= 5 ; PPNext+=4 ) {
1035 for ( PT = 0 ; PT <= 2 ; PT++ ) {
1036 if ( PT == 0 && PP == 5 ) {
1037 *_Trace << endl << "T1a 2**(6n1+2)(3n0) + 2**(6n1+1) + S2(3n1+0) --> 6(3n0+0)+5"
1039 Compute( "T1a" , T1a , PT , PP , PPNext ) ;
1041 if ( PT == 1 && PP == 1 ) {
1042 *_Trace << endl << "T2b 2**(6n1+3)(3n0+1) + S2(3n1+0) --> 6(3n0+1)+1"
1044 Compute( "T2b" , T2b , PT , PP , PPNext ) ;
1046 if ( PT == 0 && PP == 1 ) {
1047 *_Trace << endl << "T2a 2**(6n1+7)(3n0) + S2(3n1+2) --> 6(3n0+0)+1"
1049 Compute( "T2a" , T2a , PT , PP , PPNext ) ;
1051 if ( PT == 2 && PP == 5 ) {
1052 *_Trace << endl << "T1c 2**(6n1+4)(3n0+2) + 2**(6n1+3) + S2(3n1+1) --> 6(3n0+2)+5"
1054 Compute( "T1c" , T1c , PT , PP , PPNext ) ;
1056 if ( PT == 2 && PP == 1 ) {
1057 *_Trace << endl << "T2c 2**(6n1+5)(3n0+2) + S2(3n1+1) --> 6(3n0+2)+1"
1059 Compute( "T2c" , T2c , PT , PP , PPNext ) ;
1061 if ( PT == 1 && PP == 5 ) {
1062 *_Trace << endl << "T1b 2**(6n1+6)(3n0+1) + 2**(6n1+5) + S2(3n1+2) --> 6(3n0+1)+5"
1064 Compute( "T1b" , T1b , PT , PP , PPNext ) ;
1067 // for ( PPNext = 1 ; PPNext <= 5 ; PPNext+=4 ) {
1068 *_Trace << endl << "P2a1 (1<<(6*n1+3))*(3*n0+0) + S2(3*n1+0) --> 6(3n0+0)+1"
1070 Compute( "P2a1" , P2a1 , PT , PP , PPNext ) ;
1072 *_Trace << endl << "P2a2 (1<<(6*n1+5))*(3*n0+0) + S2(3*n1+1) --> 6(3n0+0)+1"
1074 Compute( "P2a2" , P2a2 , PT , PP , PPNext ) ;
1076 *_Trace << endl << "P1b1 (1<<(6*n1+2))*(3*n0+1) + (1<<(6*n1+1)) + S2(3*n1+0) --> 6(3n0+1)+5"
1078 Compute( "P1b1" , P1b1 , PT , PP , PPNext ) ;
1080 *_Trace << endl << "P1c1 (1<<(6*n1+2))*(3*n0+2) + (1<<(6*n1+1)) + S2(3*n1+0) --> 6(3n0+2)+5"
1082 Compute( "P1c1" , P1c1 , PT , PP , PPNext ) ;
1084 *_Trace << endl << "P1a1 (1<<(6*n1+4))*(3*n0+0) + (1<<(6*n1+3)) + S2(3*n1+1) --> 6(3n0+0)+5"
1086 Compute( "P1a1" , P1a1 , PT , PP , PPNext ) ;
1088 *_Trace << endl << "P2c1 (1<<(6*n1+3))*(3*n0+2) + S2(3*n1+0) --> 6(3n0+2)+1"
1090 Compute( "P2c1" , P2c1 , PT , PP , PPNext ) ;
1092 *_Trace << endl << "P1b2 (1<<(6*n1+4))*(3*n0+1) + (1<<(6*n1+3)) + S2(3*n1+1) --> 6(3n0+1)+5"
1094 Compute( "P1b2" , P1b2 , PT , PP , PPNext ) ;
1096 *_Trace << endl << "P2b1 (1<<(6*n1+5))*(3*n0+1) + S2(3*n1+1) --> 6(3n0+1)+1"
1098 Compute( "P2b1" , P2b1 , PT , PP , PPNext ) ;
1100 *_Trace << endl << "P1a2 (1<<(6*n1+6))*(3*n0+0) + (1<<(6*n1+5)) + S2(3*n1+2) --> 6(3n0)+5"
1102 Compute( "P1a2" , P1a2 , PT , PP , PPNext ) ;
1104 *_Trace << endl << "P2b2 (1<<(6*n1+7))*(3*n0+1) + S2(3*n1+2) --> 6(3n0+1)+1"
1106 Compute( "P2b2" , P2b2 , PT , PP , PPNext ) ;
1108 *_Trace << endl << "P1c2 (1<<(6*n1+6))*(3*n0+2) + (1<<(6*n1+5)) + S2(3*n1+2) --> 6(3n0+2)+5"
1110 Compute( "P1c2" , P1c2 , PT , PP , PPNext ) ;
1112 *_Trace << endl << "P2c2 (1<<(6*n1+7))*(3*n0+2) + S2(3*n1+2) --> 6(3n0+2)+1"
1114 Compute( "P2c2" , P2c2 , PT , PP , PPNext ) ;