1 // SuperVisionTest SyrComponent : example of component performing some mathinatical operations
3 // Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
24 // File : SyrComponent_CheckOfUndefined.cxx
25 // Module : SuperVisionTest
36 // ------------------------------------------------------------------
37 // NextPrime : Compute the first prime number greater or equal than an integer
38 // ------------------------------------------------------------------
42 long NextPrime (const long me )
45 struct svalue {int signiaib ;
48 struct svalue values[VALUESNBR] ;
53 // int signiaib[4] = { -1 , +1 , +1 , -1 } ;
75 // Standard_RangeError::
76 // Raise("Try to apply NextPrime method with negative, null or too large value.");
93 minn = ( me - 1 ) / 6 ; // n minimum
94 while ( 6*minn+1 < me ) {
98 maxia = long( sqrt( (double)me ) / 6 + 1 ) ;
100 maxvn = minn + VALUESNBR ;
103 for ( nindd = 0 ; nindd < VALUESNBR ; nindd++ ) {
104 if ( 6*(nindd+minn)-1 < me ) {
105 values[nindd].nbr = 1 ;
106 values[nindd].signiaib = -1 ;
110 values[nindd].nbr = 0 ;
111 values[nindd].signiaib = 0 ;
115 for ( ia = 1 ; ia <= maxia ; ia++ ) {
116 if ( nbvalues == VALUESNBR*2 ) {
119 remain = -VALUESNBR ;
120 ib[0] = ( minn + ia - remain ) / (6*ia - 1) ;
121 n[0] = int ( 6*ia*ib[0] - ia - ib[0] - minn ) ;
122 ib[1] = ( minn - ia - remain ) / (6*ia - 1) ;
123 n[1] = int ( 6*ia*ib[1] + ia - ib[1] - minn ) ;
124 ib[2] = ( minn + ia - remain ) / (6*ia + 1) ;
125 n[2] = int ( 6*ia*ib[2] - ia + ib[2] - minn ) ;
126 ib[3] = ( minn - ia - remain ) / (6*ia + 1) ;
127 n[3] = int ( 6*ia*ib[3] + ia + ib[3] - minn ) ;
128 for ( loop = 0 ; loop < 4 ; loop++ ) {
129 if ( n[loop] >= 0 && n[loop] < VALUESNBR ) {
130 if ( ( values[n[loop]].nbr == 0 ) ||
131 ( values[n[loop]].signiaib == signiaib[loop] ) ) {
132 values[n[loop]].signiaib = -signiaib[loop] ;
133 values[n[loop]].nbr += 1 ;
134 if ( values[n[loop]].nbr <= 2 )
140 for ( nindd = 0 ; nindd < VALUESNBR ; nindd++ ) {
141 if ( values[nindd].nbr == 0 ) {
142 if ( me <= 6*(nindd+minn)-1 ) {
143 premret = 6*(nindd+minn)-1 ;
146 else if ( me <= 6*(nindd+minn)+1 ) {
147 premret = 6*(nindd+minn)+1 ;
151 else if ( values[nindd].nbr == 1 ) {
152 if ( values[nindd].signiaib > 0 ) {
153 if ( me <= 6*(nindd+minn)-1 ) {
154 premret = 6*(nindd+minn)-1 ;
159 if ( me <= 6*(nindd+minn)+1 ) {
160 premret = 6*(nindd+minn)+1 ;
167 if ( premret != 0 ) {
171 return NextPrime ( 6*(maxvn-1)+2) ;
175 static char * base( int b , long n ) {
184 sprintf( ccc ,"%d" , ( n % b ) ) ;
194 static char * B2( long n ) {
195 return base( 2 , n ) ;
198 static char * B3( long n ) {
199 return base( 3 , n ) ;
202 static char * B4( long n ) {
203 return base( 4 , n ) ;
206 static char * B5( long n ) {
207 return base( 5 , n ) ;
210 static char * B7( long n ) {
211 return base( 7 , n ) ;
214 static char * B8( long n ) {
215 return base( 8 , n ) ;
218 static long S( long f , long n ) {
221 for ( i = 0 ; i <= n ; i++ ) {
227 static long S2( long n ) {
231 static long S6( long n ) {
235 static long rP( long odd ) {
236 if ( (( odd - 1 ) % 6 ) == 0 )
238 if ( (( odd - 3 ) % 6 ) == 0 )
240 if ( (( odd - 5 ) % 6 ) == 0 )
244 static long nP( long odd ) {
248 static long rQ( long N ) {
249 if ( ( N & 7 ) == 5 ) {
254 static long nQ( long N ) {
255 if ( ( N & 3 ) == 3 ) {
263 static long rT( long N ) {
264 return ( nP( N ) % 3 ) ;
266 static long nT( long N ) {
267 return ( nP( N ) / 3 ) ;
270 static char * fact( int n ) {
271 static char chn[132] ;
273 strcpy( chn , "0" ) ;
276 strcpy( chn , "1" ) ;
281 while ( (n & 1 ) == 0 ) {
285 while ( ( n % 3 ) == 0 ) {
292 sprintf( &chn[pos] , "%d" , 2 ) ;
295 sprintf( &chn[pos] , "2**%d" , pow2 ) ;
297 pos = strlen( chn ) ;
301 strcat( chn , "*" ) ;
302 pos = strlen( chn ) ;
305 sprintf( &chn[pos] , "%d" , 3 ) ;
308 sprintf( &chn[pos] , "3**%d" , pow3 ) ;
310 pos = strlen( chn ) ;
313 if ( pow2 || pow3 ) {
314 sprintf( &chn[pos] , "*%d" , n ) ;
317 sprintf( &chn[pos] , "%d" , n ) ;
324 static long Next( const long prev , long &pow2 ) {
325 long next = ( 3*prev + 1 )/2 ;
327 while ( ( next & 1 ) == 0 ) {
328 next = ( next >> 1 ) ;
334 int T1a( int n0 , int n1 ) {
335 return (1<<(6*n1+2))*(3*n0+0) + (1<<(6*n1+1)) + S2(3*n1+0) ;
337 int T1b( int n0 , int n1 ) {
338 return (1<<(6*n1+6))*(3*n0+1) + (1<<(6*n1+5)) + S2(3*n1+2) ;
340 int T1c( int n0 , int n1 ) {
341 return (1<<(6*n1+4))*(3*n0+2) + (1<<(6*n1+3)) + S2(3*n1+1) ;
343 int T2a( int n0 , int n1 ) {
344 return (1<<(6*n1+7))*(3*n0+0) + S2(3*n1+2) ;
346 int T2b( int n0 , int n1 ) {
347 return (1<<(6*n1+3))*(3*n0+1) + S2(3*n1+0) ;
349 int T2c( int n0 , int n1 ) {
350 return (1<<(6*n1+5))*(3*n0+2) + S2(3*n1+1) ;
353 int P1a1( int n0 , int n1 ) {
354 return (1<<(6*n1+4))*(3*n0+0) + (1<<(6*n1+3)) + S2(3*n1+1) ;
356 int P1a2( int n0 , int n1 ) {
357 return (1<<(6*n1+6))*(3*n0+0) + (1<<(6*n1+5)) + S2(3*n1+2) ;
359 int P1b1( int n0 , int n1 ) {
360 return (1<<(6*n1+2))*(3*n0+1) + (1<<(6*n1+1)) + S2(3*n1+0) ;
362 int P1b2( int n0 , int n1 ) {
363 return (1<<(6*n1+4))*(3*n0+1) + (1<<(6*n1+3)) + S2(3*n1+1) ;
365 int P1c1( int n0 , int n1 ) {
366 return (1<<(6*n1+2))*(3*n0+2) + (1<<(6*n1+1)) + S2(3*n1+0) ;
368 int P1c2( int n0 , int n1 ) {
369 return (1<<(6*n1+6))*(3*n0+2) + (1<<(6*n1+5)) + S2(3*n1+2) ;
372 int P2a1( int n0 , int n1 ) {
373 return (1<<(6*n1+3))*(3*n0+0) + S2(3*n1+0) ;
375 int P2a2( int n0 , int n1 ) {
376 return (1<<(6*n1+5))*(3*n0+0) + S2(3*n1+1) ;
378 int P2b1( int n0 , int n1 ) {
379 return (1<<(6*n1+5))*(3*n0+1) + S2(3*n1+1) ;
381 int P2b2( int n0 , int n1 ) {
382 return (1<<(6*n1+7))*(3*n0+1) + S2(3*n1+2) ;
384 int P2c1( int n0 , int n1 ) {
385 return (1<<(6*n1+3))*(3*n0+2) + S2(3*n1+0) ;
387 int P2c2( int n0 , int n1 ) {
388 return (1<<(6*n1+7))*(3*n0+2) + S2(3*n1+2) ;
391 typedef int (*fct)(int,int);
395 void Compute( char * fctname , fct afct , int PT , int PP , int PPNext ) {
400 for ( n1 = 0 ; n1 <= 3 ; n1++ ) {
402 for ( n0 = 0 ; n0 <= 500 && value < 3000 ; n0++ ) {
403 value = afct( n0 , n1 ) ;
405 next = Next( value , pow2 ) ;
407 if ( ( rP( value ) == 3 && rP( Next( next , kp2 ) ) == PPNext ) ||
408 ( rT( value ) == PT && rP( value ) == PP &&
409 rP( next ) == PPNext ) ) {
410 if ( rQ( value ) == 3 ||
411 ( rQ( value ) == 1 && ( nQ( value ) & 1 ) == 0 ) ) {
413 // *_Trace << " n1 " << n1 ;
414 // *_Trace << " n0 " << n0 << " " ;
420 else if ( value < 100 )
422 else if ( value < 1000 )
424 *_Trace << value << " " ;
425 long lownext = (next-1)/4 ;
426 if ( 4*lownext+1 == next && ( lownext & 1 ) == 1 ) {
429 *_Trace << fctname << " n0 " << n0 << " " ;
431 *_Trace << value << " = 6[3*" << nT( value ) << "+"
432 << rT( value ) << "]+" << rP( value ) << " --> "
433 << next << " (>>" << pow2 << ") = 6[3*"
434 << nT( next ) << "+" << rT( next )
435 << "] + " << rP( next ) << endl ;
440 *_Trace << " n1 " << n1 ;
441 *_Trace << " n0 " << n0 << " " ;
445 *_Trace << " n0 " << n0 << " " ;
447 *_Trace << "---" << value << " = 6[3*" << nT( value ) << "+"
448 << rT( value ) << "]+" << rP( value ) << " = 4*["
449 << "2*" << nQ( value )/2 << "+1]+1" ;
450 if ( Next( (value-1)/4 , kp2 ) != next )
451 *_Trace << " " << Next( (value-1)/4 , kp2 ) << " != " << next ;
461 int SeqSyr( int n ) {
470 *_Trace << " " << n ;
472 n = Next( n , pow2 ) ;
483 if ( ( nstep % 2 ) == 0 ) {
484 *_Trace << endl << " " ;
488 *_Trace << " -> " << n << " = " << EQ << "*" << q << "+" << r
489 << " = 6*" << Sq << "+" << Sr ;
495 if ( r == 5 && q > nn/8 ) {
501 void little( int depth , int prt , int n , int r ) {
511 *_Trace << endl << depth << " little2 n = " << n << " r = " << r << endl ;
515 if ( ( r0 % 3 ) == 0 ) {
517 if ( depth == prt ) {
518 *_Trace << "n->3n " << n0 << "n + " << r1 << " = 4[ "
519 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
523 else if ( ( ( n0 + r0 ) % 3 ) == 0 ) {
524 r1 = ( n0 + r0 ) / 3 ;
525 if ( depth == prt ) {
526 *_Trace << "n->3n+1 " << n0 << "n + " << r1 << " = 4[ "
527 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
531 else if ( ( ( 2*n0 + r0 ) % 3 ) == 0 ) {
532 r1 = ( 2*n0 + r0 ) / 3 ;
533 if ( depth == prt ) {
534 *_Trace << "n->3n+2 " << n0 << "n + " << r1 << " = 4[ "
535 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
541 *_Trace << endl << depth << " little4 n = " << n << " r = " << r << endl ;
545 if ( ( r2 % 3 ) == 0 ) {
547 if ( depth == prt ) {
548 *_Trace << "n->3n " << n1 << "n + " << r2 << " = 8[ "
549 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
553 else if ( ( ( n1 + r2 ) % 3 ) == 0 ) {
554 r2 = ( n1 + r2 ) / 3 ;
555 if ( depth == prt ) {
556 *_Trace << "n->3n+1 " << n1 << "n + " << r2 << " = 8[ "
557 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
561 else if ( ( ( 2*n1 + r2 ) % 3 ) == 0 ) {
562 r2 = ( 2*n1 + r2 ) / 3 ;
563 if ( depth == prt ) {
564 *_Trace << "n->3n+2 " << n1 << "n + " << r2 << " = 8[ "
565 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
571 little( depth , prt , n0 , r1 ) ;
572 little( depth , prt , n1 , r2 ) ;
577 int main(int argc, char **argv) {
589 _Trace = new ofstream( "/cas_01/jr/linux/SyrP.log" );
591 for ( l = 0 ; l <= 17 ; l++ ) {
592 for ( l1 = -1 ; l1 <= 1 ; l1 += 2 ) {
594 if ( P > 0 && NextPrime( P-1 ) == P ) {
595 for ( k = -1 ; k <= 1 ; k += 2 ) {
596 for ( i = 1 ; i <= 30 ; i++ ) {
597 for ( j = 1 ; j <= 30 ; j++ ) {
598 n = int( pow( (double)2 , (double)i ) * pow( (double)3 , (double)j )*P ) + k ;
599 if ( n < 0 || n > pow( (double)2 , (double)30 ) ) {
602 if ( NextPrime( n-1 ) == n ) {
603 *_Trace << n << " = 2**" << i << " * 3**" << j << " * " << P << " + "
607 if ( NextPrime( n-1 ) != n && ( n % P ) == 0 ) {
608 *_Trace << n << " = 2**" << i << " * 3**" << j << " * " << P << " + "
612 while ( ( n % p ) == 0 ) {
613 *_Trace << p << "*" ;
616 p = NextPrime( p + 1 ) ;
618 *_Trace << n << endl ;
631 _Trace = new ofstream( "/cas_01/jr/linux/Syr.log" );
637 for ( prt = 1 ; prt <= 5 ; prt++ ) {
638 *_Trace << endl << prt << ". 8n + 1 :" << endl ;
639 little( 0 , prt , 8 , 1 ) ;
642 for ( prt = 1 ; prt <= 5 ; prt++ ) {
643 *_Trace << endl << prt << ". 4n + 3 :" << endl ;
644 little( 0 , prt , 4 , 3 ) ;
647 for ( prt = 1 ; prt <= 6 ; prt++ ) {
648 *_Trace << endl << prt << ". 8n + 5 :" << endl ;
649 little( 0 , prt , 8 , 5 ) ;
655 for ( i = 0 ; i <= max ; i++ ) {
656 *_Trace << endl << endl << "8*" << i << "+5 = 4[2*" << i << "+1]+1 = " ;
658 while ( ((ii-1) & 7) == 4 ) {
659 *_Trace << endl << " 8*" << ii/8 << "+5 = 4[2*" << ii/4
663 *_Trace << "6*" << nP(8*i + 5) << "+" << rP(8*i + 5) << " :" << endl ;
664 n = SeqSyr( 8*i + 5 ) ;
666 while ( n && n > max ) {
667 *_Trace << endl << " ==> 8*" << n << "+5 = 4[2*" << n << "+1]+1 = " ;
669 while ( ((ii-1) & 7) == 4 ) {
670 *_Trace << endl << "8*" << ii/8 << "+5 = 4[2*" << ii/4 << "+1]+1 = " ;
673 *_Trace << "6*" << nP(8*n + 5) << "+" << rP(8*n + 5) << " :" << endl ;
674 n = SeqSyr( 8*n + 5 ) ;
693 *_Trace << "2**[x(n+1)] = (2**x-1)*S[x](n)+1" << endl << endl ;
695 *_Trace << "2**[(2x+1)(2n+rn+1)] = (2**(2x+1)-1)*S[2x+1](2n+rn)+1" << endl ;
696 *_Trace << " = 2**(2x+1){(2**(2x+1)-1)*S[2x+1](2n+rn)-1}"
698 *_Trace << "2**[2x(3n+rn+1)] = (2**2x-1)*S[2x](3n+rn)+1" << endl ;
699 *_Trace << " = 2**2x{(2**2x-1)*S[2x](3n+rn-1)-1}"
701 *_Trace << "2**(2x+1)-1 = 6S2(x-1)+1" << endl << endl ;
703 *_Trace << "2**(2(3x+1))-1 = 3(6*2*7*S6(x-1)+1) *4 :" << endl ;
704 *_Trace << "2**(2(3x+2))-1 = 3(6*2**3*7*S6(x-1)+5) *4 :" << endl ;
705 *_Trace << "2**(2(3x+3))-1 = 3(6*2**5*7*S6(x-1)+21)" << endl ;
706 *_Trace << " = 3**2(2**6*7*S6(x-1)+7)" << endl ;
707 *_Trace << " = 3**2*7(2**6*S6(x-1)+1)" << endl ;
708 *_Trace << " = 3**2*7*S6(x)" << endl ;
709 *_Trace << "2**(2(3x))-1 = 3**2*7*S6(x-1)" << endl ;
710 *_Trace << "2**(2(3x+4))-1 = 3(6*2*7*S6(x)+1) *4 :" << endl ;
711 *_Trace << "2**(2(3x+5))-1 = 3(6*2**3*7*S6(x)+5)" << endl << endl ;
712 *_Trace << "2**(2(3x+rx))-1 = 3**2*2**(2rx)*7*S6(x-1)+2**(2rx)-1" << endl
715 *_Trace << "2**[(2x+1)(2n+rn+1)] = (6S2(x-1)+1)*S[2x+1](2n+rn)+1" << endl ;
716 *_Trace << "2**[2(3x+rx)(3n+rn+1)] = {3**2*2**(2rx)*7*S6(x-1)+2**(2rx)-1}*"
717 << endl << " S[2(3x+rx)](3n+rn)+1" << endl
720 *_Trace << "(6x+5)y+x = 2**3*7*S6(x-1)" << endl ;
721 *_Trace << "x = 0 ; y = 0" << endl ;
722 *_Trace << "x = 1 ; y = 5" << endl ;
723 *_Trace << "x = 2 ; y = 214 = 2*107 = 2*O153" << endl ;
724 *_Trace << "x = 3 ; y = 10131 = 3*3377 = 3*O6461" << endl ;
725 *_Trace << "x = 4 ; y = 514244 = 4*128561 = 4*O373061" << endl ;
726 *_Trace << "x = 5 ; y = ?" << endl ;
727 *_Trace << "x = 6 ; y = 1489853154 = 6*248308859 = 6*O1663162173" << endl
730 for ( pow = 1 ; pow <= 31 ; pow++ ) {
732 for ( x = 0 ; x <= 30 ; x++ ) {
733 for ( n = 0 ; n <= 30 ; n++ ) {
734 for ( rn = 0 ; rn <= 1 ; rn++ ) {
735 if ( (2*x+1)*(2*n+rn+1) == pow && (2*x+1)*(2*n+rn+1) <= 31 ) {
736 int val = (1 << (2*x+1)*(2*n+rn+1)) ;
737 *_Trace << "2**(" << 2*x+1 << "*(" << 2*n+rn << "+1)) = " ;
738 *_Trace << "2**[(2*" << x << "+1)(2*" << n << "+" << rn
742 while ( SIG && (SIG % 3) == 0 ) {
746 *_Trace << "3**" << pow3 << "*" << SIG
747 << "+1) * " << fact( S(2*x+1,2*n+rn) )
749 << " (6*S2(" << x-1 << ")+1)*S" << 2*x+1 << "("
750 << 2*n+rn << ")+1 = "
751 << "(6*S2(" << x << "-1)+1)*S[2*" << x << "+1](2*"
752 << n << "+" << rn << ")+1 = " << val << endl ;
753 if ( val != (6*S(2,x-1)+1)*S(2*x+1,2*n+rn)+1 ) {
754 *_Trace << val << " != " << (6*S(2,x-1)+1)*S(2*x+1,2*n+rn)+1
761 for ( x = 0 ; x <= 30 ; x++ ) {
762 for ( rx = 0 ; rx <= 2 ; rx++ ) {
763 for ( n = 0 ; n <= 30 ; n++ ) {
764 for ( rn = 0 ; rn <= 2 ; rn++ ) {
765 if ( 3*x+rx != 0 && 2*(3*x+rx)*(3*n+rn+1) == pow
766 && 2*(3*x+rx)*(3*n+rn+1) <= 31 ) {
767 *_Trace << "2**[" << 2*(3*x+rx) << "*(" << 3*n+rn << "+1)] = " ;
768 *_Trace << "2**[2(3*" << x << "+" << rx << ")(3*" << n << "+"
769 << rn << "+1)] = [9*" << (1 << (2*rx)) << "*7*"
771 int DRX = (1 << (2*rx))-1 ;
773 while ( DRX && (DRX % 3) == 0 ) {
777 *_Trace << "3**" << pow3 << "*" << DRX << "] * " ;
778 int SIG = S(2*(3*x+rx),3*n+rn) ;
780 while ( SIG && (SIG % 3) == 0 ) {
784 *_Trace << "3**" << pow3 << "*" << fact( SIG )
786 << " [3**2*2**" << 2*rx << "*7*S6("
787 << x << "-1)+" << (1 << (2*rx))-1 << "] * S"
788 << 2*(3*x+rx) << "(" << 3*n+rn << ")+1 = " << endl
789 << " {3**2*2**(2*" << rx << ")*7*S6("
790 << x << "-1)+2**(2*" << rx << ")-1} * S[2(3*"
791 << x << "+" << rx << ")](3*" << n << "+" << rn << ")+1"
793 int val = (1 << (2*(3*x+rx)*(3*n+rn+1)) ) ;
794 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 ) {
795 *_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 ;
807 for ( x = 1 ; x <= 30 ; x++ ) {
808 for ( n = 0 ; n <= 30 ; n++ ) {
809 if ( x*(n+1) <= 30 ) {
810 X = ((1 << x ) - 1)*S(x,n) + 1 ;
811 if ( (1 << (x*(n+1)) ) == X ) {
812 *_Trace << "2**[" << x << "(" << n << "+1)] = 2**[[" ;
817 while ( p && (p & 1) == 0 ) {
821 while ( p && (p % 3) == 0 ) {
828 *_Trace << "**" << pow2 ;
830 if ( pow3 || p != 1 ) {
837 *_Trace << "**" << pow3 ;
843 if ( !((pow2 || pow3) && p == 1) ) {
850 while ( p && (p & 1) == 0 ) {
854 while ( p && (p % 3) == 0 ) {
861 *_Trace << "**" << pow2 ;
863 if ( pow3 || p != 1 ) {
870 *_Trace << "**" << pow3 ;
876 if ( !((pow2 || pow3) && p == 1) ) {
880 int d = (1 << x) - 1 ;
882 while ( (d % 3) == 0 ) {
886 *_Trace << " = (2**" << x << "-1)*S" ;
888 *_Trace << x << "[2*" << n/2 ;
892 *_Trace << "]+1 = " ;
895 *_Trace << x << "[3*" << n/3 << "+" << (n % 3) << "]+1 = " ;
901 *_Trace << "**" << pow3 ;
912 *_Trace << "[6*" << nP(d) << "+" << rP(d) << "]" ;
915 *_Trace << "[" << rP(d) << "]" ;
921 while ( (Y % 2) == 0 ) {
926 while ( (Y % 3) == 0 ) {
933 *_Trace << "**" << pow2 ;
940 *_Trace << "**" << pow3 ;
944 if ( nP(Y) && ( (nP(Y) & 1) == 0 || (nP(Y) % 3) == 0 ) ) {
948 while ( (YY % 2) == 0 ) {
953 while ( (YY % 3) == 0 ) {
960 *_Trace << "**" << pow2 ;
967 *_Trace << "**" << pow3 ;
971 *_Trace << YY << "+" << rP(Y) << "]}+1" << endl ;
975 *_Trace << "[6*" << nP(Y) << "+" << rP(Y) << "]}+1" << endl ;
978 *_Trace << "[" << rP(Y) << "]}+1" << endl ;
983 *_Trace << endl << (1 << (x*(n+1)) ) << " = 2**[" << x << "(" << n
984 << "+1)] != " << X << "(2**" << x
985 << "-1)*S" << x << "[" << n << "]+1" << endl ;
992 *_Trace << "S[x]( n ) = Sigma((2**x)*i) i = 0 , n" << endl ;
993 *_Trace << "S[x]( aq + r ) = X*S[a*x]( q - 1 ) + Sx( r )" << endl ;
994 for ( x = 2 ; x <= 10 ; x++ ) {
995 *_Trace << endl << endl ;
996 for ( a = 2 ; a <= 12 ; a++ ) {
998 for ( q = 1 ; q <= 12 ; q++ ) {
999 for ( r = 0 ; r < a ; r++ ) {
1000 if ( a*q + r <= 24 ) {
1001 int i = S( x , a*q+r ) - S( x , r ) ;
1002 int X = i / S( a*x , q-1 ) ;
1004 if ( X*S( a*x , q-1 ) == i && (i % S( a*x , q-1 ) ) == 0 ) {
1005 while ( ( X & 1 ) == 0 ) {
1010 while ( X > 0 && ( X % 3 ) == 0 ) {
1014 *_Trace << "S( " << x << " , " << a << "*" << q << " + " << r
1015 << " ) = 2**" << p2 << "*3**" << p3 << "*"<< X
1016 << "*S[" << a << "*" << x << "]( " << q << "-1 ) + S( "
1017 << x << " , " << r << " )" << endl ;
1029 for ( PP = 1 ; PP <= 5 ; PP+=4 ) {
1030 for ( PPNext = 1 ; PPNext <= 5 ; PPNext+=4 ) {
1031 for ( PT = 0 ; PT <= 2 ; PT++ ) {
1032 if ( PT == 0 && PP == 5 ) {
1033 *_Trace << endl << "T1a 2**(6n1+2)(3n0) + 2**(6n1+1) + S2(3n1+0) --> 6(3n0+0)+5"
1035 Compute( "T1a" , T1a , PT , PP , PPNext ) ;
1037 if ( PT == 1 && PP == 1 ) {
1038 *_Trace << endl << "T2b 2**(6n1+3)(3n0+1) + S2(3n1+0) --> 6(3n0+1)+1"
1040 Compute( "T2b" , T2b , PT , PP , PPNext ) ;
1042 if ( PT == 0 && PP == 1 ) {
1043 *_Trace << endl << "T2a 2**(6n1+7)(3n0) + S2(3n1+2) --> 6(3n0+0)+1"
1045 Compute( "T2a" , T2a , PT , PP , PPNext ) ;
1047 if ( PT == 2 && PP == 5 ) {
1048 *_Trace << endl << "T1c 2**(6n1+4)(3n0+2) + 2**(6n1+3) + S2(3n1+1) --> 6(3n0+2)+5"
1050 Compute( "T1c" , T1c , PT , PP , PPNext ) ;
1052 if ( PT == 2 && PP == 1 ) {
1053 *_Trace << endl << "T2c 2**(6n1+5)(3n0+2) + S2(3n1+1) --> 6(3n0+2)+1"
1055 Compute( "T2c" , T2c , PT , PP , PPNext ) ;
1057 if ( PT == 1 && PP == 5 ) {
1058 *_Trace << endl << "T1b 2**(6n1+6)(3n0+1) + 2**(6n1+5) + S2(3n1+2) --> 6(3n0+1)+5"
1060 Compute( "T1b" , T1b , PT , PP , PPNext ) ;
1063 // for ( PPNext = 1 ; PPNext <= 5 ; PPNext+=4 ) {
1064 *_Trace << endl << "P2a1 (1<<(6*n1+3))*(3*n0+0) + S2(3*n1+0) --> 6(3n0+0)+1"
1066 Compute( "P2a1" , P2a1 , PT , PP , PPNext ) ;
1068 *_Trace << endl << "P2a2 (1<<(6*n1+5))*(3*n0+0) + S2(3*n1+1) --> 6(3n0+0)+1"
1070 Compute( "P2a2" , P2a2 , PT , PP , PPNext ) ;
1072 *_Trace << endl << "P1b1 (1<<(6*n1+2))*(3*n0+1) + (1<<(6*n1+1)) + S2(3*n1+0) --> 6(3n0+1)+5"
1074 Compute( "P1b1" , P1b1 , PT , PP , PPNext ) ;
1076 *_Trace << endl << "P1c1 (1<<(6*n1+2))*(3*n0+2) + (1<<(6*n1+1)) + S2(3*n1+0) --> 6(3n0+2)+5"
1078 Compute( "P1c1" , P1c1 , PT , PP , PPNext ) ;
1080 *_Trace << endl << "P1a1 (1<<(6*n1+4))*(3*n0+0) + (1<<(6*n1+3)) + S2(3*n1+1) --> 6(3n0+0)+5"
1082 Compute( "P1a1" , P1a1 , PT , PP , PPNext ) ;
1084 *_Trace << endl << "P2c1 (1<<(6*n1+3))*(3*n0+2) + S2(3*n1+0) --> 6(3n0+2)+1"
1086 Compute( "P2c1" , P2c1 , PT , PP , PPNext ) ;
1088 *_Trace << endl << "P1b2 (1<<(6*n1+4))*(3*n0+1) + (1<<(6*n1+3)) + S2(3*n1+1) --> 6(3n0+1)+5"
1090 Compute( "P1b2" , P1b2 , PT , PP , PPNext ) ;
1092 *_Trace << endl << "P2b1 (1<<(6*n1+5))*(3*n0+1) + S2(3*n1+1) --> 6(3n0+1)+1"
1094 Compute( "P2b1" , P2b1 , PT , PP , PPNext ) ;
1096 *_Trace << endl << "P1a2 (1<<(6*n1+6))*(3*n0+0) + (1<<(6*n1+5)) + S2(3*n1+2) --> 6(3n0)+5"
1098 Compute( "P1a2" , P1a2 , PT , PP , PPNext ) ;
1100 *_Trace << endl << "P2b2 (1<<(6*n1+7))*(3*n0+1) + S2(3*n1+2) --> 6(3n0+1)+1"
1102 Compute( "P2b2" , P2b2 , PT , PP , PPNext ) ;
1104 *_Trace << endl << "P1c2 (1<<(6*n1+6))*(3*n0+2) + (1<<(6*n1+5)) + S2(3*n1+2) --> 6(3n0+2)+5"
1106 Compute( "P1c2" , P1c2 , PT , PP , PPNext ) ;
1108 *_Trace << endl << "P2c2 (1<<(6*n1+7))*(3*n0+2) + S2(3*n1+2) --> 6(3n0+2)+1"
1110 Compute( "P2c2" , P2c2 , PT , PP , PPNext ) ;