1 // Copyright (C) 2007-2008 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.
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
22 // SuperVisionTest SyrComponent : example of component performing some mathinatical operations
23 // File : SyrComponent_CheckOfUndefined.cxx
24 // Module : SuperVisionTest
37 // ------------------------------------------------------------------
38 // NextPrime : Compute the first prime number greater or equal than an integer
39 // ------------------------------------------------------------------
43 long NextPrime (const long me )
46 struct svalue {int signiaib ;
49 struct svalue values[VALUESNBR] ;
54 // int signiaib[4] = { -1 , +1 , +1 , -1 } ;
76 // Standard_RangeError::
77 // Raise("Try to apply NextPrime method with negative, null or too large value.");
94 minn = ( me - 1 ) / 6 ; // n minimum
95 while ( 6*minn+1 < me ) {
99 maxia = long( sqrt( (double)me ) / 6 + 1 ) ;
101 maxvn = minn + VALUESNBR ;
104 for ( nindd = 0 ; nindd < VALUESNBR ; nindd++ ) {
105 if ( 6*(nindd+minn)-1 < me ) {
106 values[nindd].nbr = 1 ;
107 values[nindd].signiaib = -1 ;
111 values[nindd].nbr = 0 ;
112 values[nindd].signiaib = 0 ;
116 for ( ia = 1 ; ia <= maxia ; ia++ ) {
117 if ( nbvalues == VALUESNBR*2 ) {
120 remain = -VALUESNBR ;
121 ib[0] = ( minn + ia - remain ) / (6*ia - 1) ;
122 n[0] = int ( 6*ia*ib[0] - ia - ib[0] - minn ) ;
123 ib[1] = ( minn - ia - remain ) / (6*ia - 1) ;
124 n[1] = int ( 6*ia*ib[1] + ia - ib[1] - minn ) ;
125 ib[2] = ( minn + ia - remain ) / (6*ia + 1) ;
126 n[2] = int ( 6*ia*ib[2] - ia + ib[2] - minn ) ;
127 ib[3] = ( minn - ia - remain ) / (6*ia + 1) ;
128 n[3] = int ( 6*ia*ib[3] + ia + ib[3] - minn ) ;
129 for ( loop = 0 ; loop < 4 ; loop++ ) {
130 if ( n[loop] >= 0 && n[loop] < VALUESNBR ) {
131 if ( ( values[n[loop]].nbr == 0 ) ||
132 ( values[n[loop]].signiaib == signiaib[loop] ) ) {
133 values[n[loop]].signiaib = -signiaib[loop] ;
134 values[n[loop]].nbr += 1 ;
135 if ( values[n[loop]].nbr <= 2 )
141 for ( nindd = 0 ; nindd < VALUESNBR ; nindd++ ) {
142 if ( values[nindd].nbr == 0 ) {
143 if ( me <= 6*(nindd+minn)-1 ) {
144 premret = 6*(nindd+minn)-1 ;
147 else if ( me <= 6*(nindd+minn)+1 ) {
148 premret = 6*(nindd+minn)+1 ;
152 else if ( values[nindd].nbr == 1 ) {
153 if ( values[nindd].signiaib > 0 ) {
154 if ( me <= 6*(nindd+minn)-1 ) {
155 premret = 6*(nindd+minn)-1 ;
160 if ( me <= 6*(nindd+minn)+1 ) {
161 premret = 6*(nindd+minn)+1 ;
168 if ( premret != 0 ) {
172 return NextPrime ( 6*(maxvn-1)+2) ;
176 static char * base( int b , long n ) {
185 sprintf( ccc ,"%d" , ( n % b ) ) ;
195 static char * B2( long n ) {
196 return base( 2 , n ) ;
199 static char * B3( long n ) {
200 return base( 3 , n ) ;
203 static char * B4( long n ) {
204 return base( 4 , n ) ;
207 static char * B5( long n ) {
208 return base( 5 , n ) ;
211 static char * B7( long n ) {
212 return base( 7 , n ) ;
215 static char * B8( long n ) {
216 return base( 8 , n ) ;
219 static long S( long f , long n ) {
222 for ( i = 0 ; i <= n ; i++ ) {
228 static long S2( long n ) {
232 static long S6( long n ) {
236 static long rP( long odd ) {
237 if ( (( odd - 1 ) % 6 ) == 0 )
239 if ( (( odd - 3 ) % 6 ) == 0 )
241 if ( (( odd - 5 ) % 6 ) == 0 )
245 static long nP( long odd ) {
249 static long rQ( long N ) {
250 if ( ( N & 7 ) == 5 ) {
255 static long nQ( long N ) {
256 if ( ( N & 3 ) == 3 ) {
264 static long rT( long N ) {
265 return ( nP( N ) % 3 ) ;
267 static long nT( long N ) {
268 return ( nP( N ) / 3 ) ;
271 static char * fact( int n ) {
272 static char chn[132] ;
274 strcpy( chn , "0" ) ;
277 strcpy( chn , "1" ) ;
282 while ( (n & 1 ) == 0 ) {
286 while ( ( n % 3 ) == 0 ) {
293 sprintf( &chn[pos] , "%d" , 2 ) ;
296 sprintf( &chn[pos] , "2**%d" , pow2 ) ;
298 pos = strlen( chn ) ;
302 strcat( chn , "*" ) ;
303 pos = strlen( chn ) ;
306 sprintf( &chn[pos] , "%d" , 3 ) ;
309 sprintf( &chn[pos] , "3**%d" , pow3 ) ;
311 pos = strlen( chn ) ;
314 if ( pow2 || pow3 ) {
315 sprintf( &chn[pos] , "*%d" , n ) ;
318 sprintf( &chn[pos] , "%d" , n ) ;
325 static long Next( const long prev , long &pow2 ) {
326 long next = ( 3*prev + 1 )/2 ;
328 while ( ( next & 1 ) == 0 ) {
329 next = ( next >> 1 ) ;
335 int T1a( int n0 , int n1 ) {
336 return (1<<(6*n1+2))*(3*n0+0) + (1<<(6*n1+1)) + S2(3*n1+0) ;
338 int T1b( int n0 , int n1 ) {
339 return (1<<(6*n1+6))*(3*n0+1) + (1<<(6*n1+5)) + S2(3*n1+2) ;
341 int T1c( int n0 , int n1 ) {
342 return (1<<(6*n1+4))*(3*n0+2) + (1<<(6*n1+3)) + S2(3*n1+1) ;
344 int T2a( int n0 , int n1 ) {
345 return (1<<(6*n1+7))*(3*n0+0) + S2(3*n1+2) ;
347 int T2b( int n0 , int n1 ) {
348 return (1<<(6*n1+3))*(3*n0+1) + S2(3*n1+0) ;
350 int T2c( int n0 , int n1 ) {
351 return (1<<(6*n1+5))*(3*n0+2) + S2(3*n1+1) ;
354 int P1a1( int n0 , int n1 ) {
355 return (1<<(6*n1+4))*(3*n0+0) + (1<<(6*n1+3)) + S2(3*n1+1) ;
357 int P1a2( int n0 , int n1 ) {
358 return (1<<(6*n1+6))*(3*n0+0) + (1<<(6*n1+5)) + S2(3*n1+2) ;
360 int P1b1( int n0 , int n1 ) {
361 return (1<<(6*n1+2))*(3*n0+1) + (1<<(6*n1+1)) + S2(3*n1+0) ;
363 int P1b2( int n0 , int n1 ) {
364 return (1<<(6*n1+4))*(3*n0+1) + (1<<(6*n1+3)) + S2(3*n1+1) ;
366 int P1c1( int n0 , int n1 ) {
367 return (1<<(6*n1+2))*(3*n0+2) + (1<<(6*n1+1)) + S2(3*n1+0) ;
369 int P1c2( int n0 , int n1 ) {
370 return (1<<(6*n1+6))*(3*n0+2) + (1<<(6*n1+5)) + S2(3*n1+2) ;
373 int P2a1( int n0 , int n1 ) {
374 return (1<<(6*n1+3))*(3*n0+0) + S2(3*n1+0) ;
376 int P2a2( int n0 , int n1 ) {
377 return (1<<(6*n1+5))*(3*n0+0) + S2(3*n1+1) ;
379 int P2b1( int n0 , int n1 ) {
380 return (1<<(6*n1+5))*(3*n0+1) + S2(3*n1+1) ;
382 int P2b2( int n0 , int n1 ) {
383 return (1<<(6*n1+7))*(3*n0+1) + S2(3*n1+2) ;
385 int P2c1( int n0 , int n1 ) {
386 return (1<<(6*n1+3))*(3*n0+2) + S2(3*n1+0) ;
388 int P2c2( int n0 , int n1 ) {
389 return (1<<(6*n1+7))*(3*n0+2) + S2(3*n1+2) ;
392 typedef int (*fct)(int,int);
396 void Compute( char * fctname , fct afct , int PT , int PP , int PPNext ) {
401 for ( n1 = 0 ; n1 <= 3 ; n1++ ) {
403 for ( n0 = 0 ; n0 <= 500 && value < 3000 ; n0++ ) {
404 value = afct( n0 , n1 ) ;
406 next = Next( value , pow2 ) ;
408 if ( ( rP( value ) == 3 && rP( Next( next , kp2 ) ) == PPNext ) ||
409 ( rT( value ) == PT && rP( value ) == PP &&
410 rP( next ) == PPNext ) ) {
411 if ( rQ( value ) == 3 ||
412 ( rQ( value ) == 1 && ( nQ( value ) & 1 ) == 0 ) ) {
414 // *_Trace << " n1 " << n1 ;
415 // *_Trace << " n0 " << n0 << " " ;
421 else if ( value < 100 )
423 else if ( value < 1000 )
425 *_Trace << value << " " ;
426 long lownext = (next-1)/4 ;
427 if ( 4*lownext+1 == next && ( lownext & 1 ) == 1 ) {
430 *_Trace << fctname << " n0 " << n0 << " " ;
432 *_Trace << value << " = 6[3*" << nT( value ) << "+"
433 << rT( value ) << "]+" << rP( value ) << " --> "
434 << next << " (>>" << pow2 << ") = 6[3*"
435 << nT( next ) << "+" << rT( next )
436 << "] + " << rP( next ) << endl ;
441 *_Trace << " n1 " << n1 ;
442 *_Trace << " n0 " << n0 << " " ;
446 *_Trace << " n0 " << n0 << " " ;
448 *_Trace << "---" << value << " = 6[3*" << nT( value ) << "+"
449 << rT( value ) << "]+" << rP( value ) << " = 4*["
450 << "2*" << nQ( value )/2 << "+1]+1" ;
451 if ( Next( (value-1)/4 , kp2 ) != next )
452 *_Trace << " " << Next( (value-1)/4 , kp2 ) << " != " << next ;
462 int SeqSyr( int n ) {
471 *_Trace << " " << n ;
473 n = Next( n , pow2 ) ;
484 if ( ( nstep % 2 ) == 0 ) {
485 *_Trace << endl << " " ;
489 *_Trace << " -> " << n << " = " << EQ << "*" << q << "+" << r
490 << " = 6*" << Sq << "+" << Sr ;
496 if ( r == 5 && q > nn/8 ) {
502 void little( int depth , int prt , int n , int r ) {
512 *_Trace << endl << depth << " little2 n = " << n << " r = " << r << endl ;
516 if ( ( r0 % 3 ) == 0 ) {
518 if ( depth == prt ) {
519 *_Trace << "n->3n " << n0 << "n + " << r1 << " = 4[ "
520 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
524 else if ( ( ( n0 + r0 ) % 3 ) == 0 ) {
525 r1 = ( n0 + r0 ) / 3 ;
526 if ( depth == prt ) {
527 *_Trace << "n->3n+1 " << n0 << "n + " << r1 << " = 4[ "
528 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
532 else if ( ( ( 2*n0 + r0 ) % 3 ) == 0 ) {
533 r1 = ( 2*n0 + r0 ) / 3 ;
534 if ( depth == prt ) {
535 *_Trace << "n->3n+2 " << n0 << "n + " << r1 << " = 4[ "
536 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
542 *_Trace << endl << depth << " little4 n = " << n << " r = " << r << endl ;
546 if ( ( r2 % 3 ) == 0 ) {
548 if ( depth == prt ) {
549 *_Trace << "n->3n " << n1 << "n + " << r2 << " = 8[ "
550 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
554 else if ( ( ( n1 + r2 ) % 3 ) == 0 ) {
555 r2 = ( n1 + r2 ) / 3 ;
556 if ( depth == prt ) {
557 *_Trace << "n->3n+1 " << n1 << "n + " << r2 << " = 8[ "
558 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
562 else if ( ( ( 2*n1 + r2 ) % 3 ) == 0 ) {
563 r2 = ( 2*n1 + r2 ) / 3 ;
564 if ( depth == prt ) {
565 *_Trace << "n->3n+2 " << n1 << "n + " << r2 << " = 8[ "
566 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
572 little( depth , prt , n0 , r1 ) ;
573 little( depth , prt , n1 , r2 ) ;
578 int main(int argc, char **argv) {
590 _Trace = new ofstream( "/cas_01/jr/linux/SyrP.log" );
592 for ( l = 0 ; l <= 17 ; l++ ) {
593 for ( l1 = -1 ; l1 <= 1 ; l1 += 2 ) {
595 if ( P > 0 && NextPrime( P-1 ) == P ) {
596 for ( k = -1 ; k <= 1 ; k += 2 ) {
597 for ( i = 1 ; i <= 30 ; i++ ) {
598 for ( j = 1 ; j <= 30 ; j++ ) {
599 n = int( pow( (double)2 , (double)i ) * pow( (double)3 , (double)j )*P ) + k ;
600 if ( n < 0 || n > pow( (double)2 , (double)30 ) ) {
603 if ( NextPrime( n-1 ) == n ) {
604 *_Trace << n << " = 2**" << i << " * 3**" << j << " * " << P << " + "
608 if ( NextPrime( n-1 ) != n && ( n % P ) == 0 ) {
609 *_Trace << n << " = 2**" << i << " * 3**" << j << " * " << P << " + "
613 while ( ( n % p ) == 0 ) {
614 *_Trace << p << "*" ;
617 p = NextPrime( p + 1 ) ;
619 *_Trace << n << endl ;
632 _Trace = new ofstream( "/cas_01/jr/linux/Syr.log" );
638 for ( prt = 1 ; prt <= 5 ; prt++ ) {
639 *_Trace << endl << prt << ". 8n + 1 :" << endl ;
640 little( 0 , prt , 8 , 1 ) ;
643 for ( prt = 1 ; prt <= 5 ; prt++ ) {
644 *_Trace << endl << prt << ". 4n + 3 :" << endl ;
645 little( 0 , prt , 4 , 3 ) ;
648 for ( prt = 1 ; prt <= 6 ; prt++ ) {
649 *_Trace << endl << prt << ". 8n + 5 :" << endl ;
650 little( 0 , prt , 8 , 5 ) ;
656 for ( i = 0 ; i <= max ; i++ ) {
657 *_Trace << endl << endl << "8*" << i << "+5 = 4[2*" << i << "+1]+1 = " ;
659 while ( ((ii-1) & 7) == 4 ) {
660 *_Trace << endl << " 8*" << ii/8 << "+5 = 4[2*" << ii/4
664 *_Trace << "6*" << nP(8*i + 5) << "+" << rP(8*i + 5) << " :" << endl ;
665 n = SeqSyr( 8*i + 5 ) ;
667 while ( n && n > max ) {
668 *_Trace << endl << " ==> 8*" << n << "+5 = 4[2*" << n << "+1]+1 = " ;
670 while ( ((ii-1) & 7) == 4 ) {
671 *_Trace << endl << "8*" << ii/8 << "+5 = 4[2*" << ii/4 << "+1]+1 = " ;
674 *_Trace << "6*" << nP(8*n + 5) << "+" << rP(8*n + 5) << " :" << endl ;
675 n = SeqSyr( 8*n + 5 ) ;
694 *_Trace << "2**[x(n+1)] = (2**x-1)*S[x](n)+1" << endl << endl ;
696 *_Trace << "2**[(2x+1)(2n+rn+1)] = (2**(2x+1)-1)*S[2x+1](2n+rn)+1" << endl ;
697 *_Trace << " = 2**(2x+1){(2**(2x+1)-1)*S[2x+1](2n+rn)-1}"
699 *_Trace << "2**[2x(3n+rn+1)] = (2**2x-1)*S[2x](3n+rn)+1" << endl ;
700 *_Trace << " = 2**2x{(2**2x-1)*S[2x](3n+rn-1)-1}"
702 *_Trace << "2**(2x+1)-1 = 6S2(x-1)+1" << endl << endl ;
704 *_Trace << "2**(2(3x+1))-1 = 3(6*2*7*S6(x-1)+1) *4 :" << endl ;
705 *_Trace << "2**(2(3x+2))-1 = 3(6*2**3*7*S6(x-1)+5) *4 :" << endl ;
706 *_Trace << "2**(2(3x+3))-1 = 3(6*2**5*7*S6(x-1)+21)" << endl ;
707 *_Trace << " = 3**2(2**6*7*S6(x-1)+7)" << endl ;
708 *_Trace << " = 3**2*7(2**6*S6(x-1)+1)" << endl ;
709 *_Trace << " = 3**2*7*S6(x)" << endl ;
710 *_Trace << "2**(2(3x))-1 = 3**2*7*S6(x-1)" << endl ;
711 *_Trace << "2**(2(3x+4))-1 = 3(6*2*7*S6(x)+1) *4 :" << endl ;
712 *_Trace << "2**(2(3x+5))-1 = 3(6*2**3*7*S6(x)+5)" << endl << endl ;
713 *_Trace << "2**(2(3x+rx))-1 = 3**2*2**(2rx)*7*S6(x-1)+2**(2rx)-1" << endl
716 *_Trace << "2**[(2x+1)(2n+rn+1)] = (6S2(x-1)+1)*S[2x+1](2n+rn)+1" << endl ;
717 *_Trace << "2**[2(3x+rx)(3n+rn+1)] = {3**2*2**(2rx)*7*S6(x-1)+2**(2rx)-1}*"
718 << endl << " S[2(3x+rx)](3n+rn)+1" << endl
721 *_Trace << "(6x+5)y+x = 2**3*7*S6(x-1)" << endl ;
722 *_Trace << "x = 0 ; y = 0" << endl ;
723 *_Trace << "x = 1 ; y = 5" << endl ;
724 *_Trace << "x = 2 ; y = 214 = 2*107 = 2*O153" << endl ;
725 *_Trace << "x = 3 ; y = 10131 = 3*3377 = 3*O6461" << endl ;
726 *_Trace << "x = 4 ; y = 514244 = 4*128561 = 4*O373061" << endl ;
727 *_Trace << "x = 5 ; y = ?" << endl ;
728 *_Trace << "x = 6 ; y = 1489853154 = 6*248308859 = 6*O1663162173" << endl
731 for ( pow = 1 ; pow <= 31 ; pow++ ) {
733 for ( x = 0 ; x <= 30 ; x++ ) {
734 for ( n = 0 ; n <= 30 ; n++ ) {
735 for ( rn = 0 ; rn <= 1 ; rn++ ) {
736 if ( (2*x+1)*(2*n+rn+1) == pow && (2*x+1)*(2*n+rn+1) <= 31 ) {
737 int val = (1 << (2*x+1)*(2*n+rn+1)) ;
738 *_Trace << "2**(" << 2*x+1 << "*(" << 2*n+rn << "+1)) = " ;
739 *_Trace << "2**[(2*" << x << "+1)(2*" << n << "+" << rn
743 while ( SIG && (SIG % 3) == 0 ) {
747 *_Trace << "3**" << pow3 << "*" << SIG
748 << "+1) * " << fact( S(2*x+1,2*n+rn) )
750 << " (6*S2(" << x-1 << ")+1)*S" << 2*x+1 << "("
751 << 2*n+rn << ")+1 = "
752 << "(6*S2(" << x << "-1)+1)*S[2*" << x << "+1](2*"
753 << n << "+" << rn << ")+1 = " << val << endl ;
754 if ( val != (6*S(2,x-1)+1)*S(2*x+1,2*n+rn)+1 ) {
755 *_Trace << val << " != " << (6*S(2,x-1)+1)*S(2*x+1,2*n+rn)+1
762 for ( x = 0 ; x <= 30 ; x++ ) {
763 for ( rx = 0 ; rx <= 2 ; rx++ ) {
764 for ( n = 0 ; n <= 30 ; n++ ) {
765 for ( rn = 0 ; rn <= 2 ; rn++ ) {
766 if ( 3*x+rx != 0 && 2*(3*x+rx)*(3*n+rn+1) == pow
767 && 2*(3*x+rx)*(3*n+rn+1) <= 31 ) {
768 *_Trace << "2**[" << 2*(3*x+rx) << "*(" << 3*n+rn << "+1)] = " ;
769 *_Trace << "2**[2(3*" << x << "+" << rx << ")(3*" << n << "+"
770 << rn << "+1)] = [9*" << (1 << (2*rx)) << "*7*"
772 int DRX = (1 << (2*rx))-1 ;
774 while ( DRX && (DRX % 3) == 0 ) {
778 *_Trace << "3**" << pow3 << "*" << DRX << "] * " ;
779 int SIG = S(2*(3*x+rx),3*n+rn) ;
781 while ( SIG && (SIG % 3) == 0 ) {
785 *_Trace << "3**" << pow3 << "*" << fact( SIG )
787 << " [3**2*2**" << 2*rx << "*7*S6("
788 << x << "-1)+" << (1 << (2*rx))-1 << "] * S"
789 << 2*(3*x+rx) << "(" << 3*n+rn << ")+1 = " << endl
790 << " {3**2*2**(2*" << rx << ")*7*S6("
791 << x << "-1)+2**(2*" << rx << ")-1} * S[2(3*"
792 << x << "+" << rx << ")](3*" << n << "+" << rn << ")+1"
794 int val = (1 << (2*(3*x+rx)*(3*n+rn+1)) ) ;
795 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 ) {
796 *_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 ;
808 for ( x = 1 ; x <= 30 ; x++ ) {
809 for ( n = 0 ; n <= 30 ; n++ ) {
810 if ( x*(n+1) <= 30 ) {
811 X = ((1 << x ) - 1)*S(x,n) + 1 ;
812 if ( (1 << (x*(n+1)) ) == X ) {
813 *_Trace << "2**[" << x << "(" << n << "+1)] = 2**[[" ;
818 while ( p && (p & 1) == 0 ) {
822 while ( p && (p % 3) == 0 ) {
829 *_Trace << "**" << pow2 ;
831 if ( pow3 || p != 1 ) {
838 *_Trace << "**" << pow3 ;
844 if ( !((pow2 || pow3) && p == 1) ) {
851 while ( p && (p & 1) == 0 ) {
855 while ( p && (p % 3) == 0 ) {
862 *_Trace << "**" << pow2 ;
864 if ( pow3 || p != 1 ) {
871 *_Trace << "**" << pow3 ;
877 if ( !((pow2 || pow3) && p == 1) ) {
881 int d = (1 << x) - 1 ;
883 while ( (d % 3) == 0 ) {
887 *_Trace << " = (2**" << x << "-1)*S" ;
889 *_Trace << x << "[2*" << n/2 ;
893 *_Trace << "]+1 = " ;
896 *_Trace << x << "[3*" << n/3 << "+" << (n % 3) << "]+1 = " ;
902 *_Trace << "**" << pow3 ;
913 *_Trace << "[6*" << nP(d) << "+" << rP(d) << "]" ;
916 *_Trace << "[" << rP(d) << "]" ;
922 while ( (Y % 2) == 0 ) {
927 while ( (Y % 3) == 0 ) {
934 *_Trace << "**" << pow2 ;
941 *_Trace << "**" << pow3 ;
945 if ( nP(Y) && ( (nP(Y) & 1) == 0 || (nP(Y) % 3) == 0 ) ) {
949 while ( (YY % 2) == 0 ) {
954 while ( (YY % 3) == 0 ) {
961 *_Trace << "**" << pow2 ;
968 *_Trace << "**" << pow3 ;
972 *_Trace << YY << "+" << rP(Y) << "]}+1" << endl ;
976 *_Trace << "[6*" << nP(Y) << "+" << rP(Y) << "]}+1" << endl ;
979 *_Trace << "[" << rP(Y) << "]}+1" << endl ;
984 *_Trace << endl << (1 << (x*(n+1)) ) << " = 2**[" << x << "(" << n
985 << "+1)] != " << X << "(2**" << x
986 << "-1)*S" << x << "[" << n << "]+1" << endl ;
993 *_Trace << "S[x]( n ) = Sigma((2**x)*i) i = 0 , n" << endl ;
994 *_Trace << "S[x]( aq + r ) = X*S[a*x]( q - 1 ) + Sx( r )" << endl ;
995 for ( x = 2 ; x <= 10 ; x++ ) {
996 *_Trace << endl << endl ;
997 for ( a = 2 ; a <= 12 ; a++ ) {
999 for ( q = 1 ; q <= 12 ; q++ ) {
1000 for ( r = 0 ; r < a ; r++ ) {
1001 if ( a*q + r <= 24 ) {
1002 int i = S( x , a*q+r ) - S( x , r ) ;
1003 int X = i / S( a*x , q-1 ) ;
1005 if ( X*S( a*x , q-1 ) == i && (i % S( a*x , q-1 ) ) == 0 ) {
1006 while ( ( X & 1 ) == 0 ) {
1011 while ( X > 0 && ( X % 3 ) == 0 ) {
1015 *_Trace << "S( " << x << " , " << a << "*" << q << " + " << r
1016 << " ) = 2**" << p2 << "*3**" << p3 << "*"<< X
1017 << "*S[" << a << "*" << x << "]( " << q << "-1 ) + S( "
1018 << x << " , " << r << " )" << endl ;
1030 for ( PP = 1 ; PP <= 5 ; PP+=4 ) {
1031 for ( PPNext = 1 ; PPNext <= 5 ; PPNext+=4 ) {
1032 for ( PT = 0 ; PT <= 2 ; PT++ ) {
1033 if ( PT == 0 && PP == 5 ) {
1034 *_Trace << endl << "T1a 2**(6n1+2)(3n0) + 2**(6n1+1) + S2(3n1+0) --> 6(3n0+0)+5"
1036 Compute( "T1a" , T1a , PT , PP , PPNext ) ;
1038 if ( PT == 1 && PP == 1 ) {
1039 *_Trace << endl << "T2b 2**(6n1+3)(3n0+1) + S2(3n1+0) --> 6(3n0+1)+1"
1041 Compute( "T2b" , T2b , PT , PP , PPNext ) ;
1043 if ( PT == 0 && PP == 1 ) {
1044 *_Trace << endl << "T2a 2**(6n1+7)(3n0) + S2(3n1+2) --> 6(3n0+0)+1"
1046 Compute( "T2a" , T2a , PT , PP , PPNext ) ;
1048 if ( PT == 2 && PP == 5 ) {
1049 *_Trace << endl << "T1c 2**(6n1+4)(3n0+2) + 2**(6n1+3) + S2(3n1+1) --> 6(3n0+2)+5"
1051 Compute( "T1c" , T1c , PT , PP , PPNext ) ;
1053 if ( PT == 2 && PP == 1 ) {
1054 *_Trace << endl << "T2c 2**(6n1+5)(3n0+2) + S2(3n1+1) --> 6(3n0+2)+1"
1056 Compute( "T2c" , T2c , PT , PP , PPNext ) ;
1058 if ( PT == 1 && PP == 5 ) {
1059 *_Trace << endl << "T1b 2**(6n1+6)(3n0+1) + 2**(6n1+5) + S2(3n1+2) --> 6(3n0+1)+5"
1061 Compute( "T1b" , T1b , PT , PP , PPNext ) ;
1064 // for ( PPNext = 1 ; PPNext <= 5 ; PPNext+=4 ) {
1065 *_Trace << endl << "P2a1 (1<<(6*n1+3))*(3*n0+0) + S2(3*n1+0) --> 6(3n0+0)+1"
1067 Compute( "P2a1" , P2a1 , PT , PP , PPNext ) ;
1069 *_Trace << endl << "P2a2 (1<<(6*n1+5))*(3*n0+0) + S2(3*n1+1) --> 6(3n0+0)+1"
1071 Compute( "P2a2" , P2a2 , PT , PP , PPNext ) ;
1073 *_Trace << endl << "P1b1 (1<<(6*n1+2))*(3*n0+1) + (1<<(6*n1+1)) + S2(3*n1+0) --> 6(3n0+1)+5"
1075 Compute( "P1b1" , P1b1 , PT , PP , PPNext ) ;
1077 *_Trace << endl << "P1c1 (1<<(6*n1+2))*(3*n0+2) + (1<<(6*n1+1)) + S2(3*n1+0) --> 6(3n0+2)+5"
1079 Compute( "P1c1" , P1c1 , PT , PP , PPNext ) ;
1081 *_Trace << endl << "P1a1 (1<<(6*n1+4))*(3*n0+0) + (1<<(6*n1+3)) + S2(3*n1+1) --> 6(3n0+0)+5"
1083 Compute( "P1a1" , P1a1 , PT , PP , PPNext ) ;
1085 *_Trace << endl << "P2c1 (1<<(6*n1+3))*(3*n0+2) + S2(3*n1+0) --> 6(3n0+2)+1"
1087 Compute( "P2c1" , P2c1 , PT , PP , PPNext ) ;
1089 *_Trace << endl << "P1b2 (1<<(6*n1+4))*(3*n0+1) + (1<<(6*n1+3)) + S2(3*n1+1) --> 6(3n0+1)+5"
1091 Compute( "P1b2" , P1b2 , PT , PP , PPNext ) ;
1093 *_Trace << endl << "P2b1 (1<<(6*n1+5))*(3*n0+1) + S2(3*n1+1) --> 6(3n0+1)+1"
1095 Compute( "P2b1" , P2b1 , PT , PP , PPNext ) ;
1097 *_Trace << endl << "P1a2 (1<<(6*n1+6))*(3*n0+0) + (1<<(6*n1+5)) + S2(3*n1+2) --> 6(3n0)+5"
1099 Compute( "P1a2" , P1a2 , PT , PP , PPNext ) ;
1101 *_Trace << endl << "P2b2 (1<<(6*n1+7))*(3*n0+1) + S2(3*n1+2) --> 6(3n0+1)+1"
1103 Compute( "P2b2" , P2b2 , PT , PP , PPNext ) ;
1105 *_Trace << endl << "P1c2 (1<<(6*n1+6))*(3*n0+2) + (1<<(6*n1+5)) + S2(3*n1+2) --> 6(3n0+2)+5"
1107 Compute( "P1c2" , P1c2 , PT , PP , PPNext ) ;
1109 *_Trace << endl << "P2c2 (1<<(6*n1+7))*(3*n0+2) + S2(3*n1+2) --> 6(3n0+2)+1"
1111 Compute( "P2c2" , P2c2 , PT , PP , PPNext ) ;