#include #ifdef HAVE_LONG_DOUBLE char *pszFormat0 = "Original Guess: %.22Lf\n" "Original Value: %.22Lf\n"; char *pszFormat1 = "Method = %s\n" "Refined Guess: %.22Lf\n" "Guess^Guess: %.22Lf\n\n"; #define NUMBER long double #define POWER(X,Y) powl( (X), (Y) ) #define LOG(X) logl(X) #define SIN(X) sinl(X) #define ATOF(x) _atold(x) #else char *pszFormat0 = "Original Guess: %.16f\n" "Original Value: %.16f\n"; char *pszFormat1 = "Method = %s\n" "Refined Guess: %.16f\n" "Guess^Guess: %.16f\n\n"; #define NUMBER double #define POWER(X,Y) pow( (X), (Y) ) #define LOG(X) log(X) #define SIN(X) sin(X) #define ATOF(x) atof(x) #endif /* Public symbol that will contain the original input: */ NUMBER ldK = 5; /* Function ldf of x is x^x */ NUMBER ldf( NUMBER ldX ) { return POWER( ldX, ldX ) - ldK; } /* Function ldfPrime of x is 1st derivative of x^x */ NUMBER ldfPrime( NUMBER ldX ) { return POWER( ldX, ldX ) * LOG( ldX ) + POWER( ldX, ldX ); } /* Function ldf2Prime of x is 2nd derivative of x^x */ NUMBER ldf2Prime( NUMBER ldX ) { return POWER( ldX, ldX ) * POWER( LOG( ldX ), 2 ) + 2 * POWER( ldX, ldX ) * LOG( ldX ) + POWER( ldX, ldX - 1 ) + POWER( ldX, ldX ); } /* Function ldf3Prime of x is 3rd derivative of x^x */ NUMBER ldf3Prime( NUMBER ldX ) { return POWER( ldX, ldX ) * POWER( LOG( ldX ), 3 ) + 3 * POWER( ldX, ldX ) * POWER( LOG( ldX ), 2 ) + 3 * POWER( ldX, ldX - 1 ) * LOG( ldX ) + 3 * POWER( ldX, ldX ) * LOG( ldX ) + 3 * POWER( ldX, ldX - 1 ) - POWER( ldX, ldX - 2 ) + POWER( ldX, ldX ); } NUMBER ldf4Prime( NUMBER ldX ) { return POWER( ldX, ldX - 3 ) * ( POWER( ldX, 3 ) * POWER( LOG( ldX ), 4 ) + 4 * POWER( ldX, 3 ) * POWER( LOG( ldX ), 3 ) + 6 * POWER( ldX, 2 ) * ( ldX + 1 ) * POWER( LOG( ldX ), 2 ) + 4 * ldX * ( POWER( ldX, 2 ) + 3 * ldX - 1 ) * LOG( ldX ) + POWER( ldX, 3 ) + 6 * POWER( ldX, 2 ) - ldX + 2 ); } NUMBER ldLeeKilloughsCleverMultiPointXtoXSolver( NUMBER ldX ) { NUMBER ldf0 = ldf( ldX ); NUMBER ldf1 = ldfPrime( ldX ); NUMBER ldfOverFprime = ldf0/ldf1; NUMBER ldTrm = ldf( ldX - ldfOverFprime ); NUMBER ldNum = 6 * ldf0 * ldf0 * ldf0 - 10 * ldf0 * ldf0 * ldTrm + ldf0 * ldTrm * ldTrm; NUMBER ldDen = 6 * ldf0 * ldf0 * ldf1 - 16 * ldf0 * ldTrm * ldf1 + 5 * ldTrm * ldTrm * ldf1; return ldX - ldNum/ldDen; } NUMBER ldLeeKilloughsCleverSinglePointXtoXSolver( NUMBER ldX ) { NUMBER ldf0 = ldf( ldX ); NUMBER ldf1 = ldfPrime( ldX ); NUMBER ldf2 = ldf2Prime( ldX ); NUMBER ldNum = 16 * ldf0 * ldf1 * ldf1 * ldf1 * ldf1 - 12 * ldf0 * ldf0 * ldf1 * ldf1 * ldf2 + 3 * ldf0 * ldf0 * ldf0 * ldf2 * ldf2; NUMBER ldDen = ldf1 * ( 16 * ldf0 * ldf0 * ldf0 * ldf0 - 20 * ldf0 * ldf1 * ldf1 * ldf2 + 7 * ldf0 * ldf0 * ldf2 * ldf2 ); return ldX - ldNum/ldDen; } /* ** 2 3 2 4 3 ** f(x) f(x) f''(x) 3 f(x) f''(x) f(x) f''(x) ** x <- x - ----- - ------------ - --------------- - -------------- ** f'(x) 3 5 7 ** 2 f'(x) 8 f'(x) 4 f'(x) */ NUMBER ldLeeKilloughsSimpleSinglePointXtoXSolver( NUMBER ldX ) { NUMBER ldf0 = ldf( ldX ); NUMBER ldf1 = ldfPrime( ldX ); NUMBER ldf2 = ldfPrime( ldX ); NUMBER ldt1 = ldf0/ldf1; NUMBER ldt2 = ldf0 * ldf0 * ldf2 / ( 2 * ldf1 * ldf1 * ldf1 ); NUMBER ldt3 = ( 3 * ldf0 * ldf0 * ldf0 * ldf2 * ldf2 ) / ( 8 * ldf1 * ldf1 * ldf1 * ldf1 * ldf1 ); NUMBER ldt4 = ldf0 * ldf0 * ldf0 * ldf0 * ldf2 * ldf2 * ldf2 / ( 4 * ldf1 * ldf1 * ldf1 * ldf1 * ldf1 * ldf1 * ldf1 ); return ldX - ldt1 - ldt2 - ldt3 - ldt4; } /* ** A much simpler method for x^n-k=0 that does not involve taking roots, ** but which consequently is not exact, is: ** ** 2 3 2 ** f(x) f(x) f''(x) f(x) f''(x) 2 n - 1 ** x <- x - ----- - ------------ - ------------- * --------- ** f'(x) 3 5 n - 1 ** 2 f'(x) 6 f'(x) ** */ NUMBER ldLeeKilloughsVerySimpleSinglePointXtoXSolver( NUMBER ldX ) { NUMBER ldf0 = ldf( ldX ); NUMBER ldf1 = ldfPrime( ldX ); NUMBER ldf2 = ldfPrime( ldX ); NUMBER ldt1 = ldf0/ldf1; NUMBER ldt2 = ldf0 * ldf0 * ldf2 / ( 2 * ldf1 * ldf1 * ldf1 ); NUMBER ldt3 = ( ldf0 * ldf0 * ldf0 * ldf2 * ldf2 ) / ( 6 * ldf1 * ldf1 * ldf1 * ldf1 * ldf1 ); NUMBER ldt4 = 2 * ldX - 1 / ( ldX - 1 ); return ldX - ldt1 - ldt2 - ldt3*ldt4; } /********************************************************************/ /* Schroder's methods for root calculation, implemented in C. */ /* ----------------------------------------------------------------*/ /* Reference: "On Infinitely Many Algorithms For Solving Equations"*/ /* by Ernst Schroder, Translated by G. W. Stewart. */ /* Pages 41 and 42 are the key passages for this work. */ /* ----------------------------------------------------------------*/ /* Copyright (C) 1996 by Dann Corbit */ /* =================================================================*/ /* Inspired by the following reference: */ /* Local convergence rates can be made arbitrarily large. */ /* Ernst Schroder showed, over 100 years ago, how a family */ /* of explicit single-point formulas could be designed to */ /* have arbitrarily high orders of (local) convergence. */ /* You can obtain a translation of Schroder's paper at: */ /* */ /* ftp://thales.cs.umd.edu/pub/reports/imase.ps */ /* */ /* Web surfers may find it easier to pick it up via my home page. */ /* The URL is */ /* */ /* http://www.cs.umd.edu/~stewart/ */ /* =================================================================*/ /* A posthumous thanks to Mr. Schroder, & thanks to Pete Stewart. */ /********************************************************************/ /***************************************/ /* Method A, for Lamda = 0, Omega = 1 */ /* Also known as "Newton's Method". */ /***************************************/ NUMBER dA01Iteration( NUMBER z, /* The parameter */ NUMBER ( * f ) ( NUMBER ), /* The function */ NUMBER ( * fp1 ) ( NUMBER ) ) /* The derivative */ { NUMBER f0; /* The value of the function at z */ NUMBER f1; /* The value of the derivative at z */ f0 = f( z ); /* Evaluate the function at z */ f1 = fp1( z ); /* Evaluate the derivative at z */ z = z - f0 / f1; /* Perform the iteration */ return z; } /***************************************/ /* Method A, for any Lamda, Omega = 1 */ /* Empirical evidence demonstrated */ /* Lamda's that work well: 0, 1/3, */ /* and 1/2. For bad guesses, 0 seems */ /* often to give the best results. */ /* This method seems to depend on the */ /* function being evaluated more than */ /* the other functions do. */ /***************************************/ NUMBER dAL1Iteration( NUMBER z, /* The parameter */ NUMBER L, /* Lamda */ NUMBER ( * f ) ( NUMBER ), /* The function */ NUMBER ( * fp1 ) ( NUMBER ) ) /* The derivative */ { NUMBER dNum; /* The Numerator */ NUMBER dDen; /* The Denominator */ dNum = z * f( z ); dDen = z * fp1( z ) - L * dNum; z = z - dNum / dDen; return z; } /***************************************/ /* Method B, for Lamda = 0, Omega = 1 */ /***************************************/ NUMBER dB01Iteration( NUMBER z, /* The parameter */ NUMBER ( * f ) ( NUMBER ), /* The function */ NUMBER ( * fp1 ) ( NUMBER ), /* The derivative */ NUMBER ( * fp2 ) ( NUMBER ) ) /* 2nd derivative */ { NUMBER f0; /* The value of the function at z */ NUMBER f1; /* The value of the derivative at z */ NUMBER f2; /* The value of the second derivative at z */ f0 = f( z ); f1 = fp1( z ); f2 = fp2( z ); z = z - ( f0 * f1 ) / ( f1 * f1 - f0 * f2 ); return z; } /***************************************/ /* Method B, for any Lamda, Omega = 1 */ /* Empirical evidence demonstrated */ /* Lamda's that work well: -1/2, -3/4 */ /* The accuracy of the initial guess */ /* has much to do with which method */ /* works better. Bad guesses seem to */ /* converge faster with -.5 and good */ /* guesses work better with -.75 */ /***************************************/ NUMBER dBL1Iteration( NUMBER z, /* The parameter */ NUMBER L, /* Lamda */ NUMBER ( * f ) ( NUMBER ), /* The function */ NUMBER ( * fp1 ) ( NUMBER ), /* The derivative */ NUMBER ( * fp2 ) ( NUMBER ) ) /* 2nd derivative */ { NUMBER f0; /* The value of the function at z */ NUMBER f1; /* The value of the derivative at z */ NUMBER f2; /* The value of the second derivative at z */ NUMBER dNum; /* The Numerator */ NUMBER dDen; /* The Denominator */ f0 = f( z ); f1 = fp1( z ); f2 = fp2( z ); dNum = z * ( f0 * f1 ); dDen = z * ( f1 * f1 - f0 * f2 ) - L * f0 * f1; z = z - dNum / dDen; return z; } /**************************************/ /* Method A, for Lamda = 0, Omega = 2 */ /**************************************/ NUMBER dA02Iteration( NUMBER z, /* The parameter */ NUMBER ( * f ) ( NUMBER ), /* The function */ NUMBER ( * fp1 ) ( NUMBER ), /* The derivative */ NUMBER ( * fp2 ) ( NUMBER ) ) /* 2nd derivative */ { NUMBER f0; /* The value of the function at z */ NUMBER f1; /* The value of the derivative at z */ NUMBER f2; /* The value of the second derivative at z */ f0 = f( z ); f1 = fp1( z ); f2 = fp2( z ); z = z - ( f0 * f1 ) / ( f1 * f1 - 0.5 * f0 * f2 ); return z; } /***************************************/ /* Method A, for any Lamda, Omega = 2 */ /* Empirical evidence demonstrated */ /* Lamda's that work well: */ /* 0, 1, 2, 1+1/sqrt(2), 1-1/sqrt(2), */ /* 1 + 1/2, 1 - 1/2, 1 + 2/3, 1 - 2/3 */ /* The accuracy of the initial guess */ /* has much to do with which method */ /* works better. Bad guesses seem to */ /* converge faster with 1+1/sqrt(2) */ /* or 1-1/sqrt(2). */ /***************************************/ NUMBER dAL2Iteration( NUMBER z, /* The parameter */ NUMBER L, /* Lamda */ NUMBER ( * f ) ( NUMBER ), /* The function */ NUMBER ( * fp1 ) ( NUMBER ), /* The derivative */ NUMBER ( * fp2 ) ( NUMBER ) ) /* 2nd derivative */ { NUMBER f0; /* The value of the function at z */ NUMBER f1; /* The value of the derivative at z */ NUMBER f2; /* The value of the second derivative at z */ NUMBER dNum; /* The Numerator */ NUMBER dDen; /* The Denominator */ f0 = f( z ); f1 = fp1( z ); f2 = fp2( z ); dNum = z * f0 * ( z * f1 - L * f0 ); dDen = z * z * ( f1 * f1 - 0.5 * f0 * f2 ); dDen -= L * z * f0 * f1; dDen += L * ( L - 1. ) * 0.5 * f0 * f0; z = z - dNum / dDen; return z; } /***************************************/ /* Method B, for Lamda = 0, Omega = 2 */ /***************************************/ NUMBER dB02Iteration( NUMBER z, /* The parameter */ NUMBER ( * f ) ( NUMBER ), /* The function */ NUMBER ( * fp1 ) ( NUMBER ), /* The derivative */ NUMBER ( * fp2 ) ( NUMBER ), /* 2nd derivative */ NUMBER ( * fp3 ) ( NUMBER ) ) /* 3rd derivative */ { NUMBER f0; /* The value of the function at z */ NUMBER f1; /* The value of the derivative at z */ NUMBER f2; /* The value of the second derivative at z */ NUMBER f3; /* The value of the third derivative at z */ NUMBER dNum; /* The Numerator */ NUMBER dDen; /* The Denominator */ f0 = f( z ); f1 = fp1( z ); f2 = fp2( z ); f3 = fp3( z ); dNum = f0 * ( f1 * f1 - f0 * f2 ); dDen = f1 * f1 * f1 - 1.5 * f0 * f1 * f2 + 0.5 * f1 * f1 * f3; z = z - dNum/dDen; return z; } /*****************************************************************************/ /* Crude approximation for the perfect root of a number. We want to be able */ /* to calculate what number, when raised to its own power, will be equal to */ /* the input number. For instance, if given 27, the answer will be 3, since */ /* 3 to the 3rd power is 27. This function will provide an estimate for a */ /* root solving function to begin iteration. */ /*****************************************************************************/ NUMBER ldPerfectRootGuess( NUMBER x ) { NUMBER f; /* First crude approximation */ f = .136 * LOG( x ) + 1.; /* Subtract (roughly) parabolic error term */ x = f - ( 0.0002347645197348 * ( f - 574. ) * ( f - 574. ) - 77.088 ); /* Subtract (roughly) sinusoidal error term */ x += 21.73 * SIN( 0.01030030378226 * x ); return x; } #ifdef _DEBUG #include #include int main( int argc, char **argv ) { NUMBER xi; NUMBER OriginalGuess; NUMBER L; NUMBER Sqrt2Inv = 1/1.41421356237309504880; char pszString[255]; if ( argc < 2) { printf( "Enter a number to find roots of:" ); fgets( pszString, sizeof( pszString ), stdin ); puts( pszString ); } else strncpy( pszString, argv[1], sizeof( pszString ) ); ldK = ATOF( pszString ); OriginalGuess = ldPerfectRootGuess( ldK ); printf( pszFormat0, OriginalGuess, ldK ); xi = ldLeeKilloughsCleverMultiPointXtoXSolver( OriginalGuess ); printf( pszFormat1, "Lee Killough Multi-Point", xi, POWER( xi, xi ) ); xi = ldLeeKilloughsCleverMultiPointXtoXSolver( xi ); printf( pszFormat1, "Lee Killough Multi-Point", xi, POWER( xi, xi ) ); xi = ldLeeKilloughsCleverMultiPointXtoXSolver( xi ); printf( pszFormat1, "Lee Killough Multi-Point", xi, POWER( xi, xi ) ); xi = ldLeeKilloughsCleverSinglePointXtoXSolver( OriginalGuess ); printf( pszFormat1, "Lee Killough Single-Point", xi, POWER( xi, xi ) ); xi = ldLeeKilloughsCleverSinglePointXtoXSolver( xi ); printf( pszFormat1, "Lee Killough Single-Point", xi, POWER( xi, xi ) ); xi = ldLeeKilloughsCleverSinglePointXtoXSolver( xi ); printf( pszFormat1, "Lee Killough Single-Point", xi, POWER( xi, xi ) ); /* Domain detonation: remove when compiling for long double */ #ifndef HAVE_LONG_DOUBLE xi = ldLeeKilloughsSimpleSinglePointXtoXSolver( OriginalGuess ); printf( pszFormat1, "Lee Killough Simple ", xi, POWER( xi, xi ) ); xi = ldLeeKilloughsSimpleSinglePointXtoXSolver( xi ); printf( pszFormat1, "Lee Killough Simple ", xi, POWER( xi, xi ) ); xi = ldLeeKilloughsSimpleSinglePointXtoXSolver( xi ); printf( pszFormat1, "Lee Killough Simple ", xi, POWER( xi, xi ) ); #endif xi = ldLeeKilloughsVerySimpleSinglePointXtoXSolver( OriginalGuess ); printf( pszFormat1, "Lee Killough Very Simple", xi, POWER( xi, xi ) ); xi = ldLeeKilloughsVerySimpleSinglePointXtoXSolver( xi ); printf( pszFormat1, "Lee Killough Very Simple", xi, POWER( xi, xi ) ); xi = ldLeeKilloughsVerySimpleSinglePointXtoXSolver( xi ); printf( pszFormat1, "Lee Killough Very Simple", xi, POWER( xi, xi ) ); xi = dA01Iteration( OriginalGuess, ldf, ldfPrime ); printf( pszFormat1, "Schroder A( 0, 1 ) ", xi, POWER( xi, xi ) ); xi = dA01Iteration( xi, ldf, ldfPrime ); printf( pszFormat1, "Schroder A( 0, 1 ) ", xi, POWER( xi, xi ) ); xi = dA01Iteration( xi, ldf, ldfPrime ); printf( pszFormat1, "Schroder A( 0, 1 ) ", xi, POWER( xi, xi ) ); xi = dB01Iteration( OriginalGuess, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder B( 0, 1 ) ", xi, POWER( xi, xi ) ); xi = dB01Iteration( xi, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder B( 0, 1 ) ", xi, POWER( xi, xi ) ); xi = dB01Iteration( xi, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder B( 0, 1 ) ", xi, POWER( xi, xi ) ); xi = dA02Iteration( OriginalGuess, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 0, 2 ) ", xi, POWER( xi, xi ) ); xi = dA02Iteration( xi, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 0, 2 ) ", xi, POWER( xi, xi ) ); xi = dA02Iteration( xi, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 0, 2 ) ", xi, POWER( xi, xi ) ); xi = dB02Iteration( OriginalGuess, ldf, ldfPrime, ldf2Prime, ldf3Prime ); printf( pszFormat1, "Schroder B( 0, 2 ) ", xi, POWER( xi, xi ) ); xi = dB02Iteration( xi, ldf, ldfPrime, ldf2Prime, ldf3Prime ); printf( pszFormat1, "Schroder B( 0, 2 ) ", xi, POWER( xi, xi ) ); xi = dB02Iteration( xi, ldf, ldfPrime, ldf2Prime, ldf3Prime ); printf( pszFormat1, "Schroder B( 0, 2 ) ", xi, POWER( xi, xi ) ); L = 0.5; xi = dAL1Iteration( OriginalGuess, L, ldf, ldfPrime ); printf( pszFormat1, "Schroder A( .5, 1 ) ", xi, POWER( xi, xi ) ); xi = dAL1Iteration( xi, L, ldf, ldfPrime ); printf( pszFormat1, "Schroder A( .5, 1 ) ", xi, POWER( xi, xi ) ); xi = dAL1Iteration( xi, L, ldf, ldfPrime ); printf( pszFormat1, "Schroder A( .5, 1 ) ", xi, POWER( xi, xi ) ); L = 1./3.; xi = dAL1Iteration( OriginalGuess, L, ldf, ldfPrime ); printf( pszFormat1, "Schroder A( 1/3, 1 ) ", xi, POWER( xi, xi ) ); xi = dAL1Iteration( xi, L, ldf, ldfPrime ); printf( pszFormat1, "Schroder A( 1/3, 1 ) ", xi, POWER( xi, xi ) ); xi = dAL1Iteration( xi, L, ldf, ldfPrime ); printf( pszFormat1, "Schroder A( 1/3, 1 ) ", xi, POWER( xi, xi ) ); L = -0.5; xi = dBL1Iteration( OriginalGuess, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder B( -1/2, 1 ) ", xi, POWER( xi, xi ) ); xi = dBL1Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder B( -1/2, 1 ) ", xi, POWER( xi, xi ) ); xi = dBL1Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder B( -1/2, 1 ) ", xi, POWER( xi, xi ) ); L = -0.75; xi = dBL1Iteration( OriginalGuess, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder B( -3/4, 1 ) ", xi, POWER( xi, xi ) ); xi = dBL1Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder B( -3/4, 1 ) ", xi, POWER( xi, xi ) ); xi = dBL1Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder B( -3/4, 1 ) ", xi, POWER( xi, xi ) ); L = 1.; xi = dAL2Iteration( OriginalGuess, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 1, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 1, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 1, 2 ) ", xi, POWER( xi, xi ) ); L = 2.; xi = dAL2Iteration( OriginalGuess, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 2, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 2, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 2, 2 ) ", xi, POWER( xi, xi ) ); L = 1. + Sqrt2Inv; xi = dAL2Iteration( OriginalGuess, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A(1+1/sqrt(2),2)", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A(1+1/sqrt(2),2)", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A(1+1/sqrt(2),2)", xi, POWER( xi, xi ) ); L = 1. - Sqrt2Inv; xi = dAL2Iteration( OriginalGuess, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A(1-1/sqrt(2),2)", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A(1-1/sqrt(2),2)", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A(1-1/sqrt(2),2)", xi, POWER( xi, xi ) ); L = 1.5; xi = dAL2Iteration( OriginalGuess, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 1.5, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 1.5, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 1.5, 2 ) ", xi, POWER( xi, xi ) ); L = 0.5; xi = dAL2Iteration( OriginalGuess, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 0.5, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 0.5, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 0.5, 2 ) ", xi, POWER( xi, xi ) ); L = 5./3.; xi = dAL2Iteration( OriginalGuess, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 5/3, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 5/3, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 5/3, 2 ) ", xi, POWER( xi, xi ) ); L = 1./3.; xi = dAL2Iteration( OriginalGuess, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 1/3, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 1/3, 2 ) ", xi, POWER( xi, xi ) ); xi = dAL2Iteration( xi, L, ldf, ldfPrime, ldf2Prime ); printf( pszFormat1, "Schroder A( 1/3, 2 ) ", xi, POWER( xi, xi ) ); return 0; } #endif /***************************/ /* RESULTS RESULTS RESULTS */ /***************************/ /*********************************** Compiled for long double precision Enter a number to find roots of:27 Original Guess: 1.9296876459270877265800 Original Value: 27.0000000000000000000000 Method = Lee Killough Multi-Point Refined Guess: 2.7289031783271815519300 Guess^Guess: 15.4799440223233313917000 Method = Lee Killough Multi-Point Refined Guess: 2.9972209448018714852100 Guess^Guess: 26.8430245579706782868000 Method = Lee Killough Multi-Point Refined Guess: 2.9999999999827274676400 Guess^Guess: 26.9999999990212945829000 Method = Lee Killough Single-Point Refined Guess: 2.1845160577171222129900 Guess^Guess: 5.5122254786514351130100 Method = Lee Killough Single-Point Refined Guess: 2.6594431424131556047200 Guess^Guess: 13.4805229468986573649000 Method = Lee Killough Single-Point Refined Guess: 3.1876035438744946862900 Guess^Guess: 40.2572949971297133313000 Method = Lee Killough Very Simple Refined Guess: 27.2117825169086981572000 Guess^Guess: 1102288337087653471690000000000000000000.0000000000000000000000 Method = Lee Killough Very Simple Refined Guess: 26.8387101470260743107000 Guess^Guess: 221880699640244787910000000000000000000.0000000000000000000000 Method = Lee Killough Very Simple Refined Guess: 26.4651910589248150745000 Guess^Guess: 44809136981109334382200000000000000000.0000000000000000000000 Method = Schroder A( 0, 1 ) Refined Guess: 5.9082285313089614015500 Guess^Guess: 36136.4882262010910026000000 Method = Schroder A( 0, 1 ) Refined Guess: 5.5483120020450943203600 Guess^Guess: 13453.5443455484538813000000 Method = Schroder A( 0, 1 ) Refined Guess: 5.1805230220882583220900 Guess^Guess: 5021.4474579087472281300000 Method = Schroder B( 0, 1 ) Refined Guess: 2.3798574365867919313700 Guess^Guess: 7.8729511917688381294900 Method = Schroder B( 0, 1 ) Refined Guess: 2.7294346803085888808000 Guess^Guess: 15.4964409352200407077000 Method = Schroder B( 0, 1 ) Refined Guess: 2.9340749612703734138100 Guess^Guess: 23.5285713865536442301000 Method = Schroder A( 0, 2 ) Refined Guess: 2.7385094672271241458400 Guess^Guess: 15.7810867252615785296000 Method = Schroder A( 0, 2 ) Refined Guess: 2.9937163711005348905300 Guess^Guess: 26.6464664397846325503000 Method = Schroder A( 0, 2 ) Refined Guess: 2.9999999053108451485800 Guess^Guess: 26.9999946346733261174000 Method = Schroder B( 0, 2 ) Refined Guess: 4.3012350210230196113400 Guess^Guess: 531.1695195704900736010000 Method = Schroder B( 0, 2 ) Refined Guess: 4.2993154530918119842100 Guess^Guess: 528.6685176697877609490000 Method = Schroder B( 0, 2 ) Refined Guess: 4.2973661179859572126900 Guess^Guess: 526.1412446026944687570000 Method = Schroder A( .5, 1 ) Refined Guess: 3.2606280749236682587900 Guess^Guess: 47.1720240269303646222000 Method = Schroder A( .5, 1 ) Refined Guess: 3.0433497576346225689500 Guess^Guess: 29.5807231003782334592000 Method = Schroder A( .5, 1 ) Refined Guess: 3.0011896821881242582100 Guess^Guess: 27.0675010101716399490000 Method = Schroder A( 1/3, 1 ) Refined Guess: 3.6400197701032851395500 Guess^Guess: 110.2627235490655463540000 Method = Schroder A( 1/3, 1 ) Refined Guess: 3.2699084786725929724900 Guess^Guess: 48.1375865471233800423000 Method = Schroder A( 1/3, 1 ) Refined Guess: 3.0544898683001246002000 Guess^Guess: 30.2858880072000743733000 Method = Schroder B( -1/2, 1 ) Refined Guess: 2.4393002716847639219900 Guess^Guess: 8.8035181524935750569500 Method = Schroder B( -1/2, 1 ) Refined Guess: 2.7940786535180516961300 Guess^Guess: 17.6532968068970823900000 Method = Schroder B( -1/2, 1 ) Refined Guess: 2.9648886720051010970400 Guess^Guess: 25.0872080169496420605000 Method = Schroder B( -3/4, 1 ) Refined Guess: 2.4753246937233538305500 Guess^Guess: 9.4268683370850571805200 Method = Schroder B( -3/4, 1 ) Refined Guess: 2.8276926473833286926700 Guess^Guess: 18.9021637009452729110000 Method = Schroder B( -3/4, 1 ) Refined Guess: 2.9767642138585263898000 Guess^Guess: 25.7173066692571970649000 Method = Schroder A( 1, 2 ) Refined Guess: 3.6746895232398680173600 Guess^Guess: 119.4016711269523922310000 Method = Schroder A( 1, 2 ) Refined Guess: 3.0657687347831461047400 Guess^Guess: 31.0182472064238849777000 Method = Schroder A( 1, 2 ) Refined Guess: 3.0000101099203005071400 Guess^Guess: 27.0005728602175239465000 Method = Schroder A( 2, 2 ) Refined Guess: 3.4631015036711617078700 Guess^Guess: 73.8282914110348614523000 Method = Schroder A( 2, 2 ) Refined Guess: 2.9971535094854856295200 Guess^Guess: 26.8392276840154273831000 Method = Schroder A( 2, 2 ) Refined Guess: 3.0000000060092222081600 Guess^Guess: 27.0000003404977467394000 Method = Schroder A(1+1/sqrt(2),2) Refined Guess: 3.5637544404695886812000 Guess^Guess: 92.6539142565799041587000 Method = Schroder A(1+1/sqrt(2),2) Refined Guess: 3.0126460099519817574700 Guess^Guess: 27.7268859429782611164000 Method = Schroder A(1+1/sqrt(2),2) Refined Guess: 2.9999996222398210082200 Guess^Guess: 26.9999785951609741017000 Method = Schroder A(1-1/sqrt(2),2) Refined Guess: 3.1851577773005346786900 Guess^Guess: 40.0452914265290091100000 Method = Schroder A(1-1/sqrt(2),2) Refined Guess: 3.0018810077909281498800 Guess^Guess: 27.1068092901941163839000 Method = Schroder A(1-1/sqrt(2),2) Refined Guess: 3.0000000017362658921300 Guess^Guess: 27.0000000983812215131000 Method = Schroder A( 1.5, 2 ) Refined Guess: 3.6248088226791737890800 Guess^Guess: 106.4882248554917371850000 Method = Schroder A( 1.5, 2 ) Refined Guess: 3.0308125662049502431900 Guess^Guess: 28.8081459553306136450000 Method = Schroder A( 1.5, 2 ) Refined Guess: 2.9999963415654526399700 Guess^Guess: 26.9997927046921421864000 Method = Schroder A( 0.5, 2 ) Refined Guess: 3.4208735814619503712600 Guess^Guess: 67.1761698216230849073000 Method = Schroder A( 0.5, 2 ) Refined Guess: 3.0203664369415929020900 Guess^Guess: 28.1809747749600786916000 Method = Schroder A( 0.5, 2 ) Refined Guess: 3.0000015765130500003600 Guess^Guess: 27.0000893293797762356000 Method = Schroder A( 5/3, 2 ) Refined Guess: 3.5766242860206847254200 Guess^Guess: 95.4038986056748454026000 Method = Schroder A( 5/3, 2 ) Refined Guess: 3.0158139102800918197800 Guess^Guess: 27.9122521995070182743000 Method = Schroder A( 5/3, 2 ) Refined Guess: 2.9999993067447194075800 Guess^Guess: 26.9999607184313596357000 Method = Schroder A( 1/3, 2 ) Refined Guess: 3.2372387458125180350600 Guess^Guess: 44.8288297904310494985000 Method = Schroder A( 1/3, 2 ) Refined Guess: 3.0038953861768543627800 Guess^Guess: 27.2216959130659211848000 Method = Schroder A( 1/3, 2 ) Refined Guess: 3.0000000145035182466300 Guess^Guess: 27.0000008218060772273000 **********************************/ /************************************ Compiled for double precision Enter a number to find roots of:27 Original Guess: 1.9296876459270891 Original Value: 27.0000000000000000 Method = Lee Killough Multi-Point Refined Guess: 2.7289031783271804 Guess^Guess: 15.4799440223232970 Method = Lee Killough Multi-Point Refined Guess: 2.9972209448018714 Guess^Guess: 26.8430245579706720 Method = Lee Killough Multi-Point Refined Guess: 2.9999999999827272 Guess^Guess: 26.9999999990212770 Method = Lee Killough Single-Point Refined Guess: 2.1845160577171243 Guess^Guess: 5.5122254786514562 Method = Lee Killough Single-Point Refined Guess: 2.6594431424131595 Guess^Guess: 13.4805229468987610 Method = Lee Killough Single-Point Refined Guess: 3.1876035438744963 Guess^Guess: 40.2572949971298540 Method = Lee Killough Simple Refined Guess: -41.0279898413311490 Guess^Guess: -1.#IND000000000000 Method = Lee Killough Simple Refined Guess: -1.#IND000000000000 Guess^Guess: -1.#IND000000000000 Method = Lee Killough Simple Refined Guess: -1.#IND000000000000 Guess^Guess: -1.#IND000000000000 Method = Lee Killough Very Simple Refined Guess: 27.2117825169085070 Guess^Guess: 1102288337086744700000000000000000000000.0000000000000000 Method = Lee Killough Very Simple Refined Guess: 26.8387101470258820 Guess^Guess: 221880699640061710000000000000000000000.0000000000000000 Method = Lee Killough Very Simple Refined Guess: 26.4651910589246210 Guess^Guess: 44809136981072087000000000000000000000.0000000000000000 Method = Schroder A( 0, 1 ) Refined Guess: 5.9082285313089500 Guess^Guess: 36136.4882261999450000 Method = Schroder A( 0, 1 ) Refined Guess: 5.5483120020450825 Guess^Guess: 13453.5443455480220000 Method = Schroder A( 0, 1 ) Refined Guess: 5.1805230220882459 Guess^Guess: 5021.4474579085818000 Method = Schroder B( 0, 1 ) Refined Guess: 2.3798574365867933 Guess^Guess: 7.8729511917688582 Method = Schroder B( 0, 1 ) Refined Guess: 2.7294346803085898 Guess^Guess: 15.4964409352200700 Method = Schroder B( 0, 1 ) Refined Guess: 2.9340749612703738 Guess^Guess: 23.5285713865536650 Method = Schroder A( 0, 2 ) Refined Guess: 2.7385094672271251 Guess^Guess: 15.7810867252616070 Method = Schroder A( 0, 2 ) Refined Guess: 2.9937163711005352 Guess^Guess: 26.6464664397846530 Method = Schroder A( 0, 2 ) Refined Guess: 2.9999999053108453 Guess^Guess: 26.9999946346733320 Method = Schroder B( 0, 2 ) Refined Guess: 4.3012350210230128 Guess^Guess: 531.1695195704811600 Method = Schroder B( 0, 2 ) Refined Guess: 4.2993154530918050 Guess^Guess: 528.6685176697786800 Method = Schroder B( 0, 2 ) Refined Guess: 4.2973661179859501 Guess^Guess: 526.1412446026853300 Method = Schroder A( .5, 1 ) Refined Guess: 3.2606280749236682 Guess^Guess: 47.1720240269303660 Method = Schroder A( .5, 1 ) Refined Guess: 3.0433497576346227 Guess^Guess: 29.5807231003782400 Method = Schroder A( .5, 1 ) Refined Guess: 3.0011896821881243 Guess^Guess: 27.0675010101716430 Method = Schroder A( 1/3, 1 ) Refined Guess: 3.6400197701032839 Guess^Guess: 110.2627235490652400 Method = Schroder A( 1/3, 1 ) Refined Guess: 3.2699084786725923 Guess^Guess: 48.1375865471233060 Method = Schroder A( 1/3, 1 ) Refined Guess: 3.0544898683001245 Guess^Guess: 30.2858880072000680 Method = Schroder B( -1/2, 1 ) Refined Guess: 2.4393002716847647 Guess^Guess: 8.8035181524935879 Method = Schroder B( -1/2, 1 ) Refined Guess: 2.7940786535180520 Guess^Guess: 17.6532968068970920 Method = Schroder B( -1/2, 1 ) Refined Guess: 2.9648886720051011 Guess^Guess: 25.0872080169496420 Method = Schroder B( -3/4, 1 ) Refined Guess: 2.4753246937233548 Guess^Guess: 9.4268683370850752 Method = Schroder B( -3/4, 1 ) Refined Guess: 2.8276926473833295 Guess^Guess: 18.9021637009453020 Method = Schroder B( -3/4, 1 ) Refined Guess: 2.9767642138585266 Guess^Guess: 25.7173066692572090 Method = Schroder A( 1, 2 ) Refined Guess: 3.6746895232398638 Guess^Guess: 119.4016711269512100 Method = Schroder A( 1, 2 ) Refined Guess: 3.0657687347831448 Guess^Guess: 31.0182472064238010 Method = Schroder A( 1, 2 ) Refined Guess: 3.0000101099203005 Guess^Guess: 27.0005728602175240 Method = Schroder A( 2, 2 ) Refined Guess: 3.4631015036711603 Guess^Guess: 73.8282914110346270 Method = Schroder A( 2, 2 ) Refined Guess: 2.9971535094854858 Guess^Guess: 26.8392276840154340 Method = Schroder A( 2, 2 ) Refined Guess: 3.0000000060092220 Guess^Guess: 27.0000003404977350 Method = Schroder A(1+1/sqrt(2),2) Refined Guess: 3.5637544404695869 Guess^Guess: 92.6539142565795260 Method = Schroder A(1+1/sqrt(2),2) Refined Guess: 3.0126460099519816 Guess^Guess: 27.7268859429782530 Method = Schroder A(1+1/sqrt(2),2) Refined Guess: 2.9999996222398209 Guess^Guess: 26.9999785951609650 Method = Schroder A(1-1/sqrt(2),2) Refined Guess: 3.1851577773005326 Guess^Guess: 40.0452914265288340 Method = Schroder A(1-1/sqrt(2),2) Refined Guess: 3.0018810077909279 Guess^Guess: 27.1068092901941040 Method = Schroder A(1-1/sqrt(2),2) Refined Guess: 3.0000000017362658 Guess^Guess: 27.0000000983812180 Method = Schroder A( 1.5, 2 ) Refined Guess: 3.6248088226791717 Guess^Guess: 106.4882248554912300 Method = Schroder A( 1.5, 2 ) Refined Guess: 3.0308125662049501 Guess^Guess: 28.8081459553306050 Method = Schroder A( 1.5, 2 ) Refined Guess: 2.9999963415654527 Guess^Guess: 26.9997927046921440 Method = Schroder A( 0.5, 2 ) Refined Guess: 3.4208735814619473 Guess^Guess: 67.1761698216226220 Method = Schroder A( 0.5, 2 ) Refined Guess: 3.0203664369415923 Guess^Guess: 28.1809747749600450 Method = Schroder A( 0.5, 2 ) Refined Guess: 3.0000015765130499 Guess^Guess: 27.0000893293797690 Method = Schroder A( 5/3, 2 ) Refined Guess: 3.5766242860206825 Guess^Guess: 95.4038986056743570 Method = Schroder A( 5/3, 2 ) Refined Guess: 3.0158139102800918 Guess^Guess: 27.9122521995070190 Method = Schroder A( 5/3, 2 ) Refined Guess: 2.9999993067447193 Guess^Guess: 26.9999607184313500 Method = Schroder A( 1/3, 2 ) Refined Guess: 3.2372387458125158 Guess^Guess: 44.8288297904308310 Method = Schroder A( 1/3, 2 ) Refined Guess: 3.0038953861768540 Guess^Guess: 27.2216959130659010 Method = Schroder A( 1/3, 2 ) Refined Guess: 3.0000000145035184 Guess^Guess: 27.0000008218060860 **********************************/