1 // Copyright (C) 2007-2013 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
23 // SuperVisionTest SyrComponent : example of component performing some mathinatical operations
24 // File : SyrComponent_CheckOfUndefined.cxx
25 // Module : SuperVisionTest
38 // ------------------------------------------------------------------
39 // NextPrime : Compute the first prime number greater or equal than an integer
40 // ------------------------------------------------------------------
44 long NextPrime (const long me )
47 struct svalue {int signiaib ;
50 struct svalue values[VALUESNBR] ;
55 // int signiaib[4] = { -1 , +1 , +1 , -1 } ;
77 // Standard_RangeError::
78 // Raise("Try to apply NextPrime method with negative, null or too large value.");
95 minn = ( me - 1 ) / 6 ; // n minimum
96 while ( 6*minn+1 < me ) {
100 maxia = long( sqrt( (double)me ) / 6 + 1 ) ;
102 maxvn = minn + VALUESNBR ;
105 for ( nindd = 0 ; nindd < VALUESNBR ; nindd++ ) {
106 if ( 6*(nindd+minn)-1 < me ) {
107 values[nindd].nbr = 1 ;
108 values[nindd].signiaib = -1 ;
112 values[nindd].nbr = 0 ;
113 values[nindd].signiaib = 0 ;
117 for ( ia = 1 ; ia <= maxia ; ia++ ) {
118 if ( nbvalues == VALUESNBR*2 ) {
121 remain = -VALUESNBR ;
122 ib[0] = ( minn + ia - remain ) / (6*ia - 1) ;
123 n[0] = int ( 6*ia*ib[0] - ia - ib[0] - minn ) ;
124 ib[1] = ( minn - ia - remain ) / (6*ia - 1) ;
125 n[1] = int ( 6*ia*ib[1] + ia - ib[1] - minn ) ;
126 ib[2] = ( minn + ia - remain ) / (6*ia + 1) ;
127 n[2] = int ( 6*ia*ib[2] - ia + ib[2] - minn ) ;
128 ib[3] = ( minn - ia - remain ) / (6*ia + 1) ;
129 n[3] = int ( 6*ia*ib[3] + ia + ib[3] - minn ) ;
130 for ( loop = 0 ; loop < 4 ; loop++ ) {
131 if ( n[loop] >= 0 && n[loop] < VALUESNBR ) {
132 if ( ( values[n[loop]].nbr == 0 ) ||
133 ( values[n[loop]].signiaib == signiaib[loop] ) ) {
134 values[n[loop]].signiaib = -signiaib[loop] ;
135 values[n[loop]].nbr += 1 ;
136 if ( values[n[loop]].nbr <= 2 )
142 for ( nindd = 0 ; nindd < VALUESNBR ; nindd++ ) {
143 if ( values[nindd].nbr == 0 ) {
144 if ( me <= 6*(nindd+minn)-1 ) {
145 premret = 6*(nindd+minn)-1 ;
148 else if ( me <= 6*(nindd+minn)+1 ) {
149 premret = 6*(nindd+minn)+1 ;
153 else if ( values[nindd].nbr == 1 ) {
154 if ( values[nindd].signiaib > 0 ) {
155 if ( me <= 6*(nindd+minn)-1 ) {
156 premret = 6*(nindd+minn)-1 ;
161 if ( me <= 6*(nindd+minn)+1 ) {
162 premret = 6*(nindd+minn)+1 ;
169 if ( premret != 0 ) {
173 return NextPrime ( 6*(maxvn-1)+2) ;
177 static char * base( int b , long n ) {
186 sprintf( ccc ,"%d" , ( n % b ) ) ;
196 static char * B2( long n ) {
197 return base( 2 , n ) ;
200 static char * B3( long n ) {
201 return base( 3 , n ) ;
204 static char * B4( long n ) {
205 return base( 4 , n ) ;
208 static char * B5( long n ) {
209 return base( 5 , n ) ;
212 static char * B7( long n ) {
213 return base( 7 , n ) ;
216 static char * B8( long n ) {
217 return base( 8 , n ) ;
220 static long S( long f , long n ) {
223 for ( i = 0 ; i <= n ; i++ ) {
229 static long S2( long n ) {
233 static long S6( long n ) {
237 static long rP( long odd ) {
238 if ( (( odd - 1 ) % 6 ) == 0 )
240 if ( (( odd - 3 ) % 6 ) == 0 )
242 if ( (( odd - 5 ) % 6 ) == 0 )
246 static long nP( long odd ) {
250 static long rQ( long N ) {
251 if ( ( N & 7 ) == 5 ) {
256 static long nQ( long N ) {
257 if ( ( N & 3 ) == 3 ) {
265 static long rT( long N ) {
266 return ( nP( N ) % 3 ) ;
268 static long nT( long N ) {
269 return ( nP( N ) / 3 ) ;
272 static char * fact( int n ) {
273 static char chn[132] ;
275 strcpy( chn , "0" ) ;
278 strcpy( chn , "1" ) ;
283 while ( (n & 1 ) == 0 ) {
287 while ( ( n % 3 ) == 0 ) {
294 sprintf( &chn[pos] , "%d" , 2 ) ;
297 sprintf( &chn[pos] , "2**%d" , pow2 ) ;
299 pos = strlen( chn ) ;
303 strcat( chn , "*" ) ;
304 pos = strlen( chn ) ;
307 sprintf( &chn[pos] , "%d" , 3 ) ;
310 sprintf( &chn[pos] , "3**%d" , pow3 ) ;
312 pos = strlen( chn ) ;
315 if ( pow2 || pow3 ) {
316 sprintf( &chn[pos] , "*%d" , n ) ;
319 sprintf( &chn[pos] , "%d" , n ) ;
326 static long Next( const long prev , long &pow2 ) {
327 long next = ( 3*prev + 1 )/2 ;
329 while ( ( next & 1 ) == 0 ) {
330 next = ( next >> 1 ) ;
336 int T1a( int n0 , int n1 ) {
337 return (1<<(6*n1+2))*(3*n0+0) + (1<<(6*n1+1)) + S2(3*n1+0) ;
339 int T1b( int n0 , int n1 ) {
340 return (1<<(6*n1+6))*(3*n0+1) + (1<<(6*n1+5)) + S2(3*n1+2) ;
342 int T1c( int n0 , int n1 ) {
343 return (1<<(6*n1+4))*(3*n0+2) + (1<<(6*n1+3)) + S2(3*n1+1) ;
345 int T2a( int n0 , int n1 ) {
346 return (1<<(6*n1+7))*(3*n0+0) + S2(3*n1+2) ;
348 int T2b( int n0 , int n1 ) {
349 return (1<<(6*n1+3))*(3*n0+1) + S2(3*n1+0) ;
351 int T2c( int n0 , int n1 ) {
352 return (1<<(6*n1+5))*(3*n0+2) + S2(3*n1+1) ;
355 int P1a1( int n0 , int n1 ) {
356 return (1<<(6*n1+4))*(3*n0+0) + (1<<(6*n1+3)) + S2(3*n1+1) ;
358 int P1a2( int n0 , int n1 ) {
359 return (1<<(6*n1+6))*(3*n0+0) + (1<<(6*n1+5)) + S2(3*n1+2) ;
361 int P1b1( int n0 , int n1 ) {
362 return (1<<(6*n1+2))*(3*n0+1) + (1<<(6*n1+1)) + S2(3*n1+0) ;
364 int P1b2( int n0 , int n1 ) {
365 return (1<<(6*n1+4))*(3*n0+1) + (1<<(6*n1+3)) + S2(3*n1+1) ;
367 int P1c1( int n0 , int n1 ) {
368 return (1<<(6*n1+2))*(3*n0+2) + (1<<(6*n1+1)) + S2(3*n1+0) ;
370 int P1c2( int n0 , int n1 ) {
371 return (1<<(6*n1+6))*(3*n0+2) + (1<<(6*n1+5)) + S2(3*n1+2) ;
374 int P2a1( int n0 , int n1 ) {
375 return (1<<(6*n1+3))*(3*n0+0) + S2(3*n1+0) ;
377 int P2a2( int n0 , int n1 ) {
378 return (1<<(6*n1+5))*(3*n0+0) + S2(3*n1+1) ;
380 int P2b1( int n0 , int n1 ) {
381 return (1<<(6*n1+5))*(3*n0+1) + S2(3*n1+1) ;
383 int P2b2( int n0 , int n1 ) {
384 return (1<<(6*n1+7))*(3*n0+1) + S2(3*n1+2) ;
386 int P2c1( int n0 , int n1 ) {
387 return (1<<(6*n1+3))*(3*n0+2) + S2(3*n1+0) ;
389 int P2c2( int n0 , int n1 ) {
390 return (1<<(6*n1+7))*(3*n0+2) + S2(3*n1+2) ;
393 typedef int (*fct)(int,int);
397 void Compute( char * fctname , fct afct , int PT , int PP , int PPNext ) {
402 for ( n1 = 0 ; n1 <= 3 ; n1++ ) {
404 for ( n0 = 0 ; n0 <= 500 && value < 3000 ; n0++ ) {
405 value = afct( n0 , n1 ) ;
407 next = Next( value , pow2 ) ;
409 if ( ( rP( value ) == 3 && rP( Next( next , kp2 ) ) == PPNext ) ||
410 ( rT( value ) == PT && rP( value ) == PP &&
411 rP( next ) == PPNext ) ) {
412 if ( rQ( value ) == 3 ||
413 ( rQ( value ) == 1 && ( nQ( value ) & 1 ) == 0 ) ) {
415 // *_Trace << " n1 " << n1 ;
416 // *_Trace << " n0 " << n0 << " " ;
422 else if ( value < 100 )
424 else if ( value < 1000 )
426 *_Trace << value << " " ;
427 long lownext = (next-1)/4 ;
428 if ( 4*lownext+1 == next && ( lownext & 1 ) == 1 ) {
431 *_Trace << fctname << " n0 " << n0 << " " ;
433 *_Trace << value << " = 6[3*" << nT( value ) << "+"
434 << rT( value ) << "]+" << rP( value ) << " --> "
435 << next << " (>>" << pow2 << ") = 6[3*"
436 << nT( next ) << "+" << rT( next )
437 << "] + " << rP( next ) << endl ;
442 *_Trace << " n1 " << n1 ;
443 *_Trace << " n0 " << n0 << " " ;
447 *_Trace << " n0 " << n0 << " " ;
449 *_Trace << "---" << value << " = 6[3*" << nT( value ) << "+"
450 << rT( value ) << "]+" << rP( value ) << " = 4*["
451 << "2*" << nQ( value )/2 << "+1]+1" ;
452 if ( Next( (value-1)/4 , kp2 ) != next )
453 *_Trace << " " << Next( (value-1)/4 , kp2 ) << " != " << next ;
463 int SeqSyr( int n ) {
472 *_Trace << " " << n ;
474 n = Next( n , pow2 ) ;
485 if ( ( nstep % 2 ) == 0 ) {
486 *_Trace << endl << " " ;
490 *_Trace << " -> " << n << " = " << EQ << "*" << q << "+" << r
491 << " = 6*" << Sq << "+" << Sr ;
497 if ( r == 5 && q > nn/8 ) {
503 void little( int depth , int prt , int n , int r ) {
513 *_Trace << endl << depth << " little2 n = " << n << " r = " << r << endl ;
517 if ( ( r0 % 3 ) == 0 ) {
519 if ( depth == prt ) {
520 *_Trace << "n->3n " << n0 << "n + " << r1 << " = 4[ "
521 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
525 else if ( ( ( n0 + r0 ) % 3 ) == 0 ) {
526 r1 = ( n0 + r0 ) / 3 ;
527 if ( depth == prt ) {
528 *_Trace << "n->3n+1 " << n0 << "n + " << r1 << " = 4[ "
529 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
533 else if ( ( ( 2*n0 + r0 ) % 3 ) == 0 ) {
534 r1 = ( 2*n0 + r0 ) / 3 ;
535 if ( depth == prt ) {
536 *_Trace << "n->3n+2 " << n0 << "n + " << r1 << " = 4[ "
537 << n0/4 << "n + " << r1/4 << " ]+3" << endl ;
543 *_Trace << endl << depth << " little4 n = " << n << " r = " << r << endl ;
547 if ( ( r2 % 3 ) == 0 ) {
549 if ( depth == prt ) {
550 *_Trace << "n->3n " << n1 << "n + " << r2 << " = 8[ "
551 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
555 else if ( ( ( n1 + r2 ) % 3 ) == 0 ) {
556 r2 = ( n1 + r2 ) / 3 ;
557 if ( depth == prt ) {
558 *_Trace << "n->3n+1 " << n1 << "n + " << r2 << " = 8[ "
559 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
563 else if ( ( ( 2*n1 + r2 ) % 3 ) == 0 ) {
564 r2 = ( 2*n1 + r2 ) / 3 ;
565 if ( depth == prt ) {
566 *_Trace << "n->3n+2 " << n1 << "n + " << r2 << " = 8[ "
567 << n1/8 << "n + " << r2/8 << " ]+1" << endl ;
573 little( depth , prt , n0 , r1 ) ;
574 little( depth , prt , n1 , r2 ) ;
579 int main(int argc, char **argv) {
591 _Trace = new ofstream( "/cas_01/jr/linux/SyrP.log" );
593 for ( l = 0 ; l <= 17 ; l++ ) {
594 for ( l1 = -1 ; l1 <= 1 ; l1 += 2 ) {
596 if ( P > 0 && NextPrime( P-1 ) == P ) {
597 for ( k = -1 ; k <= 1 ; k += 2 ) {
598 for ( i = 1 ; i <= 30 ; i++ ) {
599 for ( j = 1 ; j <= 30 ; j++ ) {
600 n = int( pow( (double)2 , (double)i ) * pow( (double)3 , (double)j )*P ) + k ;
601 if ( n < 0 || n > pow( (double)2 , (double)30 ) ) {
604 if ( NextPrime( n-1 ) == n ) {
605 *_Trace << n << " = 2**" << i << " * 3**" << j << " * " << P << " + "
609 if ( NextPrime( n-1 ) != n && ( n % P ) == 0 ) {
610 *_Trace << n << " = 2**" << i << " * 3**" << j << " * " << P << " + "
614 while ( ( n % p ) == 0 ) {
615 *_Trace << p << "*" ;
618 p = NextPrime( p + 1 ) ;
620 *_Trace << n << endl ;
633 _Trace = new ofstream( "/cas_01/jr/linux/Syr.log" );
639 for ( prt = 1 ; prt <= 5 ; prt++ ) {
640 *_Trace << endl << prt << ". 8n + 1 :" << endl ;
641 little( 0 , prt , 8 , 1 ) ;
644 for ( prt = 1 ; prt <= 5 ; prt++ ) {
645 *_Trace << endl << prt << ". 4n + 3 :" << endl ;
646 little( 0 , prt , 4 , 3 ) ;
649 for ( prt = 1 ; prt <= 6 ; prt++ ) {
650 *_Trace << endl << prt << ". 8n + 5 :" << endl ;
651 little( 0 , prt , 8 , 5 ) ;
657 for ( i = 0 ; i <= max ; i++ ) {
658 *_Trace << endl << endl << "8*" << i << "+5 = 4[2*" << i << "+1]+1 = " ;
660 while ( ((ii-1) & 7) == 4 ) {
661 *_Trace << endl << " 8*" << ii/8 << "+5 = 4[2*" << ii/4
665 *_Trace << "6*" << nP(8*i + 5) << "+" << rP(8*i + 5) << " :" << endl ;
666 n = SeqSyr( 8*i + 5 ) ;
668 while ( n && n > max ) {
669 *_Trace << endl << " ==> 8*" << n << "+5 = 4[2*" << n << "+1]+1 = " ;
671 while ( ((ii-1) & 7) == 4 ) {
672 *_Trace << endl << "8*" << ii/8 << "+5 = 4[2*" << ii/4 << "+1]+1 = " ;
675 *_Trace << "6*" << nP(8*n + 5) << "+" << rP(8*n + 5) << " :" << endl ;
676 n = SeqSyr( 8*n + 5 ) ;
695 *_Trace << "2**[x(n+1)] = (2**x-1)*S[x](n)+1" << endl << endl ;
697 *_Trace << "2**[(2x+1)(2n+rn+1)] = (2**(2x+1)-1)*S[2x+1](2n+rn)+1" << endl ;
698 *_Trace << " = 2**(2x+1){(2**(2x+1)-1)*S[2x+1](2n+rn)-1}"
700 *_Trace << "2**[2x(3n+rn+1)] = (2**2x-1)*S[2x](3n+rn)+1" << endl ;
701 *_Trace << " = 2**2x{(2**2x-1)*S[2x](3n+rn-1)-1}"
703 *_Trace << "2**(2x+1)-1 = 6S2(x-1)+1" << endl << endl ;
705 *_Trace << "2**(2(3x+1))-1 = 3(6*2*7*S6(x-1)+1) *4 :" << endl ;
706 *_Trace << "2**(2(3x+2))-1 = 3(6*2**3*7*S6(x-1)+5) *4 :" << endl ;
707 *_Trace << "2**(2(3x+3))-1 = 3(6*2**5*7*S6(x-1)+21)" << endl ;
708 *_Trace << " = 3**2(2**6*7*S6(x-1)+7)" << endl ;
709 *_Trace << " = 3**2*7(2**6*S6(x-1)+1)" << endl ;
710 *_Trace << " = 3**2*7*S6(x)" << endl ;
711 *_Trace << "2**(2(3x))-1 = 3**2*7*S6(x-1)" << endl ;
712 *_Trace << "2**(2(3x+4))-1 = 3(6*2*7*S6(x)+1) *4 :" << endl ;
713 *_Trace << "2**(2(3x+5))-1 = 3(6*2**3*7*S6(x)+5)" << endl << endl ;
714 *_Trace << "2**(2(3x+rx))-1 = 3**2*2**(2rx)*7*S6(x-1)+2**(2rx)-1" << endl
717 *_Trace << "2**[(2x+1)(2n+rn+1)] = (6S2(x-1)+1)*S[2x+1](2n+rn)+1" << endl ;
718 *_Trace << "2**[2(3x+rx)(3n+rn+1)] = {3**2*2**(2rx)*7*S6(x-1)+2**(2rx)-1}*"
719 << endl << " S[2(3x+rx)](3n+rn)+1" << endl
722 *_Trace << "(6x+5)y+x = 2**3*7*S6(x-1)" << endl ;
723 *_Trace << "x = 0 ; y = 0" << endl ;
724 *_Trace << "x = 1 ; y = 5" << endl ;
725 *_Trace << "x = 2 ; y = 214 = 2*107 = 2*O153" << endl ;
726 *_Trace << "x = 3 ; y = 10131 = 3*3377 = 3*O6461" << endl ;
727 *_Trace << "x = 4 ; y = 514244 = 4*128561 = 4*O373061" << endl ;
728 *_Trace << "x = 5 ; y = ?" << endl ;
729 *_Trace << "x = 6 ; y = 1489853154 = 6*248308859 = 6*O1663162173" << endl
732 for ( pow = 1 ; pow <= 31 ; pow++ ) {
734 for ( x = 0 ; x <= 30 ; x++ ) {
735 for ( n = 0 ; n <= 30 ; n++ ) {
736 for ( rn = 0 ; rn <= 1 ; rn++ ) {
737 if ( (2*x+1)*(2*n+rn+1) == pow && (2*x+1)*(2*n+rn+1) <= 31 ) {
738 int val = (1 << (2*x+1)*(2*n+rn+1)) ;
739 *_Trace << "2**(" << 2*x+1 << "*(" << 2*n+rn << "+1)) = " ;
740 *_Trace << "2**[(2*" << x << "+1)(2*" << n << "+" << rn
744 while ( SIG && (SIG % 3) == 0 ) {
748 *_Trace << "3**" << pow3 << "*" << SIG
749 << "+1) * " << fact( S(2*x+1,2*n+rn) )
751 << " (6*S2(" << x-1 << ")+1)*S" << 2*x+1 << "("
752 << 2*n+rn << ")+1 = "
753 << "(6*S2(" << x << "-1)+1)*S[2*" << x << "+1](2*"
754 << n << "+" << rn << ")+1 = " << val << endl ;
755 if ( val != (6*S(2,x-1)+1)*S(2*x+1,2*n+rn)+1 ) {
756 *_Trace << val << " != " << (6*S(2,x-1)+1)*S(2*x+1,2*n+rn)+1
763 for ( x = 0 ; x <= 30 ; x++ ) {
764 for ( rx = 0 ; rx <= 2 ; rx++ ) {
765 for ( n = 0 ; n <= 30 ; n++ ) {
766 for ( rn = 0 ; rn <= 2 ; rn++ ) {
767 if ( 3*x+rx != 0 && 2*(3*x+rx)*(3*n+rn+1) == pow
768 && 2*(3*x+rx)*(3*n+rn+1) <= 31 ) {
769 *_Trace << "2**[" << 2*(3*x+rx) << "*(" << 3*n+rn << "+1)] = " ;
770 *_Trace << "2**[2(3*" << x << "+" << rx << ")(3*" << n << "+"
771 << rn << "+1)] = [9*" << (1 << (2*rx)) << "*7*"
773 int DRX = (1 << (2*rx))-1 ;
775 while ( DRX && (DRX % 3) == 0 ) {
779 *_Trace << "3**" << pow3 << "*" << DRX << "] * " ;
780 int SIG = S(2*(3*x+rx),3*n+rn) ;
782 while ( SIG && (SIG % 3) == 0 ) {
786 *_Trace << "3**" << pow3 << "*" << fact( SIG )
788 << " [3**2*2**" << 2*rx << "*7*S6("
789 << x << "-1)+" << (1 << (2*rx))-1 << "] * S"
790 << 2*(3*x+rx) << "(" << 3*n+rn << ")+1 = " << endl
791 << " {3**2*2**(2*" << rx << ")*7*S6("
792 << x << "-1)+2**(2*" << rx << ")-1} * S[2(3*"
793 << x << "+" << rx << ")](3*" << n << "+" << rn << ")+1"
795 int val = (1 << (2*(3*x+rx)*(3*n+rn+1)) ) ;
796 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 ) {
797 *_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 ;
809 for ( x = 1 ; x <= 30 ; x++ ) {
810 for ( n = 0 ; n <= 30 ; n++ ) {
811 if ( x*(n+1) <= 30 ) {
812 X = ((1 << x ) - 1)*S(x,n) + 1 ;
813 if ( (1 << (x*(n+1)) ) == X ) {
814 *_Trace << "2**[" << x << "(" << n << "+1)] = 2**[[" ;
819 while ( p && (p & 1) == 0 ) {
823 while ( p && (p % 3) == 0 ) {
830 *_Trace << "**" << pow2 ;
832 if ( pow3 || p != 1 ) {
839 *_Trace << "**" << pow3 ;
845 if ( !((pow2 || pow3) && p == 1) ) {
852 while ( p && (p & 1) == 0 ) {
856 while ( p && (p % 3) == 0 ) {
863 *_Trace << "**" << pow2 ;
865 if ( pow3 || p != 1 ) {
872 *_Trace << "**" << pow3 ;
878 if ( !((pow2 || pow3) && p == 1) ) {
882 int d = (1 << x) - 1 ;
884 while ( (d % 3) == 0 ) {
888 *_Trace << " = (2**" << x << "-1)*S" ;
890 *_Trace << x << "[2*" << n/2 ;
894 *_Trace << "]+1 = " ;
897 *_Trace << x << "[3*" << n/3 << "+" << (n % 3) << "]+1 = " ;
903 *_Trace << "**" << pow3 ;
914 *_Trace << "[6*" << nP(d) << "+" << rP(d) << "]" ;
917 *_Trace << "[" << rP(d) << "]" ;
923 while ( (Y % 2) == 0 ) {
928 while ( (Y % 3) == 0 ) {
935 *_Trace << "**" << pow2 ;
942 *_Trace << "**" << pow3 ;
946 if ( nP(Y) && ( (nP(Y) & 1) == 0 || (nP(Y) % 3) == 0 ) ) {
950 while ( (YY % 2) == 0 ) {
955 while ( (YY % 3) == 0 ) {
962 *_Trace << "**" << pow2 ;
969 *_Trace << "**" << pow3 ;
973 *_Trace << YY << "+" << rP(Y) << "]}+1" << endl ;
977 *_Trace << "[6*" << nP(Y) << "+" << rP(Y) << "]}+1" << endl ;
980 *_Trace << "[" << rP(Y) << "]}+1" << endl ;
985 *_Trace << endl << (1 << (x*(n+1)) ) << " = 2**[" << x << "(" << n
986 << "+1)] != " << X << "(2**" << x
987 << "-1)*S" << x << "[" << n << "]+1" << endl ;
994 *_Trace << "S[x]( n ) = Sigma((2**x)*i) i = 0 , n" << endl ;
995 *_Trace << "S[x]( aq + r ) = X*S[a*x]( q - 1 ) + Sx( r )" << endl ;
996 for ( x = 2 ; x <= 10 ; x++ ) {
997 *_Trace << endl << endl ;
998 for ( a = 2 ; a <= 12 ; a++ ) {
1000 for ( q = 1 ; q <= 12 ; q++ ) {
1001 for ( r = 0 ; r < a ; r++ ) {
1002 if ( a*q + r <= 24 ) {
1003 int i = S( x , a*q+r ) - S( x , r ) ;
1004 int X = i / S( a*x , q-1 ) ;
1006 if ( X*S( a*x , q-1 ) == i && (i % S( a*x , q-1 ) ) == 0 ) {
1007 while ( ( X & 1 ) == 0 ) {
1012 while ( X > 0 && ( X % 3 ) == 0 ) {
1016 *_Trace << "S( " << x << " , " << a << "*" << q << " + " << r
1017 << " ) = 2**" << p2 << "*3**" << p3 << "*"<< X
1018 << "*S[" << a << "*" << x << "]( " << q << "-1 ) + S( "
1019 << x << " , " << r << " )" << endl ;
1031 for ( PP = 1 ; PP <= 5 ; PP+=4 ) {
1032 for ( PPNext = 1 ; PPNext <= 5 ; PPNext+=4 ) {
1033 for ( PT = 0 ; PT <= 2 ; PT++ ) {
1034 if ( PT == 0 && PP == 5 ) {
1035 *_Trace << endl << "T1a 2**(6n1+2)(3n0) + 2**(6n1+1) + S2(3n1+0) --> 6(3n0+0)+5"
1037 Compute( "T1a" , T1a , PT , PP , PPNext ) ;
1039 if ( PT == 1 && PP == 1 ) {
1040 *_Trace << endl << "T2b 2**(6n1+3)(3n0+1) + S2(3n1+0) --> 6(3n0+1)+1"
1042 Compute( "T2b" , T2b , PT , PP , PPNext ) ;
1044 if ( PT == 0 && PP == 1 ) {
1045 *_Trace << endl << "T2a 2**(6n1+7)(3n0) + S2(3n1+2) --> 6(3n0+0)+1"
1047 Compute( "T2a" , T2a , PT , PP , PPNext ) ;
1049 if ( PT == 2 && PP == 5 ) {
1050 *_Trace << endl << "T1c 2**(6n1+4)(3n0+2) + 2**(6n1+3) + S2(3n1+1) --> 6(3n0+2)+5"
1052 Compute( "T1c" , T1c , PT , PP , PPNext ) ;
1054 if ( PT == 2 && PP == 1 ) {
1055 *_Trace << endl << "T2c 2**(6n1+5)(3n0+2) + S2(3n1+1) --> 6(3n0+2)+1"
1057 Compute( "T2c" , T2c , PT , PP , PPNext ) ;
1059 if ( PT == 1 && PP == 5 ) {
1060 *_Trace << endl << "T1b 2**(6n1+6)(3n0+1) + 2**(6n1+5) + S2(3n1+2) --> 6(3n0+1)+5"
1062 Compute( "T1b" , T1b , PT , PP , PPNext ) ;
1065 // for ( PPNext = 1 ; PPNext <= 5 ; PPNext+=4 ) {
1066 *_Trace << endl << "P2a1 (1<<(6*n1+3))*(3*n0+0) + S2(3*n1+0) --> 6(3n0+0)+1"
1068 Compute( "P2a1" , P2a1 , PT , PP , PPNext ) ;
1070 *_Trace << endl << "P2a2 (1<<(6*n1+5))*(3*n0+0) + S2(3*n1+1) --> 6(3n0+0)+1"
1072 Compute( "P2a2" , P2a2 , PT , PP , PPNext ) ;
1074 *_Trace << endl << "P1b1 (1<<(6*n1+2))*(3*n0+1) + (1<<(6*n1+1)) + S2(3*n1+0) --> 6(3n0+1)+5"
1076 Compute( "P1b1" , P1b1 , PT , PP , PPNext ) ;
1078 *_Trace << endl << "P1c1 (1<<(6*n1+2))*(3*n0+2) + (1<<(6*n1+1)) + S2(3*n1+0) --> 6(3n0+2)+5"
1080 Compute( "P1c1" , P1c1 , PT , PP , PPNext ) ;
1082 *_Trace << endl << "P1a1 (1<<(6*n1+4))*(3*n0+0) + (1<<(6*n1+3)) + S2(3*n1+1) --> 6(3n0+0)+5"
1084 Compute( "P1a1" , P1a1 , PT , PP , PPNext ) ;
1086 *_Trace << endl << "P2c1 (1<<(6*n1+3))*(3*n0+2) + S2(3*n1+0) --> 6(3n0+2)+1"
1088 Compute( "P2c1" , P2c1 , PT , PP , PPNext ) ;
1090 *_Trace << endl << "P1b2 (1<<(6*n1+4))*(3*n0+1) + (1<<(6*n1+3)) + S2(3*n1+1) --> 6(3n0+1)+5"
1092 Compute( "P1b2" , P1b2 , PT , PP , PPNext ) ;
1094 *_Trace << endl << "P2b1 (1<<(6*n1+5))*(3*n0+1) + S2(3*n1+1) --> 6(3n0+1)+1"
1096 Compute( "P2b1" , P2b1 , PT , PP , PPNext ) ;
1098 *_Trace << endl << "P1a2 (1<<(6*n1+6))*(3*n0+0) + (1<<(6*n1+5)) + S2(3*n1+2) --> 6(3n0)+5"
1100 Compute( "P1a2" , P1a2 , PT , PP , PPNext ) ;
1102 *_Trace << endl << "P2b2 (1<<(6*n1+7))*(3*n0+1) + S2(3*n1+2) --> 6(3n0+1)+1"
1104 Compute( "P2b2" , P2b2 , PT , PP , PPNext ) ;
1106 *_Trace << endl << "P1c2 (1<<(6*n1+6))*(3*n0+2) + (1<<(6*n1+5)) + S2(3*n1+2) --> 6(3n0+2)+5"
1108 Compute( "P1c2" , P1c2 , PT , PP , PPNext ) ;
1110 *_Trace << endl << "P2c2 (1<<(6*n1+7))*(3*n0+2) + S2(3*n1+2) --> 6(3n0+2)+1"
1112 Compute( "P2c2" , P2c2 , PT , PP , PPNext ) ;