/************************************************************************* * Adaptive integration results * * Called after AutoGKIteration returned False. * * Input parameters: * State - algorithm state (used by AutoGKIteration). * * Output parameters: * V - integral(f(x)dx,a,b) * Rep - optimization report (see AutoGKReport description) * * -- ALGLIB -- * Copyright 14.11.2007 by Bochkanov Sergey *************************************************************************/ public static void autogkresults(ref autogkstate state, ref double v, ref autogkreport rep) { v = state.v; rep.terminationtype = state.terminationtype; rep.nfev = state.nfev; rep.nintervals = state.nintervals; }
/************************************************************************* * Integration of a smooth function F(x) on a finite interval [a,b]. * * This subroutine is same as AutoGKSmooth(), but it guarantees that interval * [a,b] is partitioned into subintervals which have width at most XWidth. * * Subroutine can be used when integrating nearly-constant function with * narrow "bumps" (about XWidth wide). If "bumps" are too narrow, AutoGKSmooth * subroutine can overlook them. * * INPUT PARAMETERS: * A, B - interval boundaries (A<B, A=B or A>B) * * OUTPUT PARAMETERS * State - structure which stores algorithm state between subsequent * calls of AutoGKIteration. Used for reverse communication. * This structure should be passed to the AutoGKIteration * subroutine. * * SEE ALSO * AutoGKSmooth, AutoGKSingular, AutoGKIteration, AutoGKResults. * * * -- ALGLIB -- * Copyright 06.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogksmoothw(double a, double b, double xwidth, ref autogkstate state) { state.wrappermode = 0; state.a = a; state.b = b; state.xwidth = xwidth; state.rstate.ra = new double[10 + 1]; state.rstate.stage = -1; }
/************************************************************************* * Integration on a finite interval [A,B]. * Integrand have integrable singularities at A/B. * * F(X) must diverge as "(x-A)^alpha" at A, as "(B-x)^beta" at B, with known * alpha/beta (alpha>-1, beta>-1). If alpha/beta are not known, estimates * from below can be used (but these estimates should be greater than -1 too). * * One of alpha/beta variables (or even both alpha/beta) may be equal to 0, * which means than function F(x) is non-singular at A/B. Anyway (singular at * bounds or not), function F(x) is supposed to be continuous on (A,B). * * Fast-convergent algorithm based on a Gauss-Kronrod formula is used. Result * is calculated with accuracy close to the machine precision. * * INPUT PARAMETERS: * A, B - interval boundaries (A<B, A=B or A>B) * Alpha - power-law coefficient of the F(x) at A, * Alpha>-1 * Beta - power-law coefficient of the F(x) at B, * Beta>-1 * * OUTPUT PARAMETERS * State - structure which stores algorithm state between subsequent * calls of AutoGKIteration. Used for reverse communication. * This structure should be passed to the AutoGKIteration * subroutine. * * SEE ALSO * AutoGKSmooth, AutoGKSmoothW, AutoGKIteration, AutoGKResults. * * * -- ALGLIB -- * Copyright 06.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogksingular(double a, double b, double alpha, double beta, ref autogkstate state) { state.wrappermode = 1; state.a = a; state.b = b; state.alpha = alpha; state.beta = beta; state.xwidth = 0.0; state.rstate.ra = new double[10 + 1]; state.rstate.stage = -1; }
/************************************************************************* Integration of a smooth function F(x) on a finite interval [a,b]. Fast-convergent algorithm based on a Gauss-Kronrod formula is used. Result is calculated with accuracy close to the machine precision. Algorithm works well only with smooth integrands. It may be used with continuous non-smooth integrands, but with less performance. It should never be used with integrands which have integrable singularities at lower or upper limits - algorithm may crash. Use AutoGKSingular in such cases. INPUT PARAMETERS: A, B - interval boundaries (A<B, A=B or A>B) OUTPUT PARAMETERS State - structure which stores algorithm state SEE ALSO AutoGKSmoothW, AutoGKSingular, AutoGKResults. -- ALGLIB -- Copyright 06.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogksmooth(double a, double b, autogkstate state) { alglib.ap.assert(math.isfinite(a), "AutoGKSmooth: A is not finite!"); alglib.ap.assert(math.isfinite(b), "AutoGKSmooth: B is not finite!"); autogksmoothw(a, b, 0.0, state); }
public override alglib.apobject make_copy() { autogkstate _result = new autogkstate(); _result.a = a; _result.b = b; _result.alpha = alpha; _result.beta = beta; _result.xwidth = xwidth; _result.x = x; _result.xminusa = xminusa; _result.bminusx = bminusx; _result.needf = needf; _result.f = f; _result.wrappermode = wrappermode; _result.internalstate = (autogkinternalstate)internalstate.make_copy(); _result.rstate = (rcommstate)rstate.make_copy(); _result.v = v; _result.terminationtype = terminationtype; _result.nfev = nfev; _result.nintervals = nintervals; return _result; }
/************************************************************************* * One step of adaptive integration process. * * Called after initialization with one of AutoGKXXX subroutines. * See HTML documentation for examples. * * Input parameters: * State - structure which stores algorithm state between calls and * which is used for reverse communication. Must be * initialized with one of AutoGKXXX subroutines. * * If suborutine returned False, iterative proces has converged. If subroutine * returned True, caller should calculate function value State.F at State.X * and call AutoGKIteration again. * * NOTE: * * When integrating "difficult" functions with integrable singularities like * * F(x) = (x-A)^alpha * (B-x)^beta * * subroutine may require the value of F at points which are too close to A/B. * Sometimes to calculate integral with high enough precision we may need to * calculate F(A+delta) when delta is less than machine epsilon. In finite * precision arithmetics A+delta will be effectively equal to A, so we may * find us in situation when we are trying to calculate something like * 1/sqrt(1-1). * * To avoid such situations, AutoGKIteration subroutine fills not only * State.X field, but also State.XMinusA (which equals to X-A) and * State.BMinusX (which equals to B-X) fields. If X is too close to A or B * (X-A<0.001*A, or B-X<0.001*B, for example) use these fields instead of * State.X * * * -- ALGLIB -- * Copyright 07.05.2009 by Bochkanov Sergey *************************************************************************/ public static bool autogkiteration(ref autogkstate state) { bool result = new bool(); double s = 0; double tmp = 0; double eps = 0; double a = 0; double b = 0; double x = 0; double t = 0; double alpha = 0; double beta = 0; double v1 = 0; double v2 = 0; // // Reverse communication preparations // I know it looks ugly, but it works the same way // anywhere from C++ to Python. // // This code initializes locals by: // * random values determined during code // generation - on first subroutine call // * values from previous call - on subsequent calls // if (state.rstate.stage >= 0) { s = state.rstate.ra[0]; tmp = state.rstate.ra[1]; eps = state.rstate.ra[2]; a = state.rstate.ra[3]; b = state.rstate.ra[4]; x = state.rstate.ra[5]; t = state.rstate.ra[6]; alpha = state.rstate.ra[7]; beta = state.rstate.ra[8]; v1 = state.rstate.ra[9]; v2 = state.rstate.ra[10]; } else { s = -983; tmp = -989; eps = -834; a = 900; b = -287; x = 364; t = 214; alpha = -338; beta = -686; v1 = 912; v2 = 585; } if (state.rstate.stage == 0) { goto lbl_0; } if (state.rstate.stage == 1) { goto lbl_1; } if (state.rstate.stage == 2) { goto lbl_2; } // // Routine body // eps = 0; a = state.a; b = state.b; alpha = state.alpha; beta = state.beta; state.terminationtype = -1; state.nfev = 0; state.nintervals = 0; // // smooth function at a finite interval // if (state.wrappermode != 0) { goto lbl_3; } // // special case // if ((double)(a) == (double)(b)) { state.terminationtype = 1; state.v = 0; result = false; return(result); } // // general case // autogkinternalprepare(a, b, eps, state.xwidth, ref state.internalstate); lbl_5: if (!autogkinternaliteration(ref state.internalstate)) { goto lbl_6; } x = state.internalstate.x; state.x = x; state.xminusa = x - a; state.bminusx = b - x; state.rstate.stage = 0; goto lbl_rcomm; lbl_0: state.nfev = state.nfev + 1; state.internalstate.f = state.f; goto lbl_5; lbl_6: state.v = state.internalstate.r; state.terminationtype = state.internalstate.info; state.nintervals = state.internalstate.heapused; result = false; return(result); lbl_3: // // function with power-law singularities at the ends of a finite interval // if (state.wrappermode != 1) { goto lbl_7; } // // test coefficients // if ((double)(alpha) <= (double)(-1) | (double)(beta) <= (double)(-1)) { state.terminationtype = -1; state.v = 0; result = false; return(result); } // // special cases // if ((double)(a) == (double)(b)) { state.terminationtype = 1; state.v = 0; result = false; return(result); } // // reduction to general form // if ((double)(a) < (double)(b)) { s = +1; } else { s = -1; tmp = a; a = b; b = tmp; tmp = alpha; alpha = beta; beta = tmp; } alpha = Math.Min(alpha, 0); beta = Math.Min(beta, 0); // // first, integrate left half of [a,b]: // integral(f(x)dx, a, (b+a)/2) = // = 1/(1+alpha) * integral(t^(-alpha/(1+alpha))*f(a+t^(1/(1+alpha)))dt, 0, (0.5*(b-a))^(1+alpha)) // autogkinternalprepare(0, Math.Pow(0.5 * (b - a), 1 + alpha), eps, state.xwidth, ref state.internalstate); lbl_9: if (!autogkinternaliteration(ref state.internalstate)) { goto lbl_10; } // // Fill State.X, State.XMinusA, State.BMinusX. // Latter two are filled correctly even if B<A. // x = state.internalstate.x; t = Math.Pow(x, 1 / (1 + alpha)); state.x = a + t; if ((double)(s) > (double)(0)) { state.xminusa = t; state.bminusx = b - (a + t); } else { state.xminusa = a + t - b; state.bminusx = -t; } state.rstate.stage = 1; goto lbl_rcomm; lbl_1: if ((double)(alpha) != (double)(0)) { state.internalstate.f = state.f * Math.Pow(x, -(alpha / (1 + alpha))) / (1 + alpha); } else { state.internalstate.f = state.f; } state.nfev = state.nfev + 1; goto lbl_9; lbl_10: v1 = state.internalstate.r; state.nintervals = state.nintervals + state.internalstate.heapused; // // then, integrate right half of [a,b]: // integral(f(x)dx, (b+a)/2, b) = // = 1/(1+beta) * integral(t^(-beta/(1+beta))*f(b-t^(1/(1+beta)))dt, 0, (0.5*(b-a))^(1+beta)) // autogkinternalprepare(0, Math.Pow(0.5 * (b - a), 1 + beta), eps, state.xwidth, ref state.internalstate); lbl_11: if (!autogkinternaliteration(ref state.internalstate)) { goto lbl_12; } // // Fill State.X, State.XMinusA, State.BMinusX. // Latter two are filled correctly (X-A, B-X) even if B<A. // x = state.internalstate.x; t = Math.Pow(x, 1 / (1 + beta)); state.x = b - t; if ((double)(s) > (double)(0)) { state.xminusa = b - t - a; state.bminusx = t; } else { state.xminusa = -t; state.bminusx = a - (b - t); } state.rstate.stage = 2; goto lbl_rcomm; lbl_2: if ((double)(beta) != (double)(0)) { state.internalstate.f = state.f * Math.Pow(x, -(beta / (1 + beta))) / (1 + beta); } else { state.internalstate.f = state.f; } state.nfev = state.nfev + 1; goto lbl_11; lbl_12: v2 = state.internalstate.r; state.nintervals = state.nintervals + state.internalstate.heapused; // // final result // state.v = s * (v1 + v2); state.terminationtype = 1; result = false; return(result); lbl_7: result = false; return(result); // // Saving state // lbl_rcomm: result = true; state.rstate.ra[0] = s; state.rstate.ra[1] = tmp; state.rstate.ra[2] = eps; state.rstate.ra[3] = a; state.rstate.ra[4] = b; state.rstate.ra[5] = x; state.rstate.ra[6] = t; state.rstate.ra[7] = alpha; state.rstate.ra[8] = beta; state.rstate.ra[9] = v1; state.rstate.ra[10] = v2; return(result); }
/************************************************************************* Integration on a finite interval [A,B]. Integrand have integrable singularities at A/B. F(X) must diverge as "(x-A)^alpha" at A, as "(B-x)^beta" at B, with known alpha/beta (alpha>-1, beta>-1). If alpha/beta are not known, estimates from below can be used (but these estimates should be greater than -1 too). One of alpha/beta variables (or even both alpha/beta) may be equal to 0, which means than function F(x) is non-singular at A/B. Anyway (singular at bounds or not), function F(x) is supposed to be continuous on (A,B). Fast-convergent algorithm based on a Gauss-Kronrod formula is used. Result is calculated with accuracy close to the machine precision. INPUT PARAMETERS: A, B - interval boundaries (A<B, A=B or A>B) Alpha - power-law coefficient of the F(x) at A, Alpha>-1 Beta - power-law coefficient of the F(x) at B, Beta>-1 OUTPUT PARAMETERS State - structure which stores algorithm state SEE ALSO AutoGKSmooth, AutoGKSmoothW, AutoGKResults. -- ALGLIB -- Copyright 06.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogksingular(double a, double b, double alpha, double beta, out autogkstate state) { state = new autogkstate(); autogk.autogksingular(a, b, alpha, beta, state.innerobj); return; }
/************************************************************************* -- ALGLIB -- Copyright 07.05.2009 by Bochkanov Sergey *************************************************************************/ public static bool autogkiteration(autogkstate state) { bool result = new bool(); double s = 0; double tmp = 0; double eps = 0; double a = 0; double b = 0; double x = 0; double t = 0; double alpha = 0; double beta = 0; double v1 = 0; double v2 = 0; // // Reverse communication preparations // I know it looks ugly, but it works the same way // anywhere from C++ to Python. // // This code initializes locals by: // * random values determined during code // generation - on first subroutine call // * values from previous call - on subsequent calls // if( state.rstate.stage>=0 ) { s = state.rstate.ra[0]; tmp = state.rstate.ra[1]; eps = state.rstate.ra[2]; a = state.rstate.ra[3]; b = state.rstate.ra[4]; x = state.rstate.ra[5]; t = state.rstate.ra[6]; alpha = state.rstate.ra[7]; beta = state.rstate.ra[8]; v1 = state.rstate.ra[9]; v2 = state.rstate.ra[10]; } else { s = -983; tmp = -989; eps = -834; a = 900; b = -287; x = 364; t = 214; alpha = -338; beta = -686; v1 = 912; v2 = 585; } if( state.rstate.stage==0 ) { goto lbl_0; } if( state.rstate.stage==1 ) { goto lbl_1; } if( state.rstate.stage==2 ) { goto lbl_2; } // // Routine body // eps = 0; a = state.a; b = state.b; alpha = state.alpha; beta = state.beta; state.terminationtype = -1; state.nfev = 0; state.nintervals = 0; // // smooth function at a finite interval // if( state.wrappermode!=0 ) { goto lbl_3; } // // special case // if( (double)(a)==(double)(b) ) { state.terminationtype = 1; state.v = 0; result = false; return result; } // // general case // autogkinternalprepare(a, b, eps, state.xwidth, state.internalstate); lbl_5: if( !autogkinternaliteration(state.internalstate) ) { goto lbl_6; } x = state.internalstate.x; state.x = x; state.xminusa = x-a; state.bminusx = b-x; state.needf = true; state.rstate.stage = 0; goto lbl_rcomm; lbl_0: state.needf = false; state.nfev = state.nfev+1; state.internalstate.f = state.f; goto lbl_5; lbl_6: state.v = state.internalstate.r; state.terminationtype = state.internalstate.info; state.nintervals = state.internalstate.heapused; result = false; return result; lbl_3: // // function with power-law singularities at the ends of a finite interval // if( state.wrappermode!=1 ) { goto lbl_7; } // // test coefficients // if( (double)(alpha)<=(double)(-1) || (double)(beta)<=(double)(-1) ) { state.terminationtype = -1; state.v = 0; result = false; return result; } // // special cases // if( (double)(a)==(double)(b) ) { state.terminationtype = 1; state.v = 0; result = false; return result; } // // reduction to general form // if( (double)(a)<(double)(b) ) { s = 1; } else { s = -1; tmp = a; a = b; b = tmp; tmp = alpha; alpha = beta; beta = tmp; } alpha = Math.Min(alpha, 0); beta = Math.Min(beta, 0); // // first, integrate left half of [a,b]: // integral(f(x)dx, a, (b+a)/2) = // = 1/(1+alpha) * integral(t^(-alpha/(1+alpha))*f(a+t^(1/(1+alpha)))dt, 0, (0.5*(b-a))^(1+alpha)) // autogkinternalprepare(0, Math.Pow(0.5*(b-a), 1+alpha), eps, state.xwidth, state.internalstate); lbl_9: if( !autogkinternaliteration(state.internalstate) ) { goto lbl_10; } // // Fill State.X, State.XMinusA, State.BMinusX. // Latter two are filled correctly even if B<A. // x = state.internalstate.x; t = Math.Pow(x, 1/(1+alpha)); state.x = a+t; if( (double)(s)>(double)(0) ) { state.xminusa = t; state.bminusx = b-(a+t); } else { state.xminusa = a+t-b; state.bminusx = -t; } state.needf = true; state.rstate.stage = 1; goto lbl_rcomm; lbl_1: state.needf = false; if( (double)(alpha)!=(double)(0) ) { state.internalstate.f = state.f*Math.Pow(x, -(alpha/(1+alpha)))/(1+alpha); } else { state.internalstate.f = state.f; } state.nfev = state.nfev+1; goto lbl_9; lbl_10: v1 = state.internalstate.r; state.nintervals = state.nintervals+state.internalstate.heapused; // // then, integrate right half of [a,b]: // integral(f(x)dx, (b+a)/2, b) = // = 1/(1+beta) * integral(t^(-beta/(1+beta))*f(b-t^(1/(1+beta)))dt, 0, (0.5*(b-a))^(1+beta)) // autogkinternalprepare(0, Math.Pow(0.5*(b-a), 1+beta), eps, state.xwidth, state.internalstate); lbl_11: if( !autogkinternaliteration(state.internalstate) ) { goto lbl_12; } // // Fill State.X, State.XMinusA, State.BMinusX. // Latter two are filled correctly (X-A, B-X) even if B<A. // x = state.internalstate.x; t = Math.Pow(x, 1/(1+beta)); state.x = b-t; if( (double)(s)>(double)(0) ) { state.xminusa = b-t-a; state.bminusx = t; } else { state.xminusa = -t; state.bminusx = a-(b-t); } state.needf = true; state.rstate.stage = 2; goto lbl_rcomm; lbl_2: state.needf = false; if( (double)(beta)!=(double)(0) ) { state.internalstate.f = state.f*Math.Pow(x, -(beta/(1+beta)))/(1+beta); } else { state.internalstate.f = state.f; } state.nfev = state.nfev+1; goto lbl_11; lbl_12: v2 = state.internalstate.r; state.nintervals = state.nintervals+state.internalstate.heapused; // // final result // state.v = s*(v1+v2); state.terminationtype = 1; result = false; return result; lbl_7: result = false; return result; // // Saving state // lbl_rcomm: result = true; state.rstate.ra[0] = s; state.rstate.ra[1] = tmp; state.rstate.ra[2] = eps; state.rstate.ra[3] = a; state.rstate.ra[4] = b; state.rstate.ra[5] = x; state.rstate.ra[6] = t; state.rstate.ra[7] = alpha; state.rstate.ra[8] = beta; state.rstate.ra[9] = v1; state.rstate.ra[10] = v2; return result; }
/************************************************************************* Integration on a finite interval [A,B]. Integrand have integrable singularities at A/B. F(X) must diverge as "(x-A)^alpha" at A, as "(B-x)^beta" at B, with known alpha/beta (alpha>-1, beta>-1). If alpha/beta are not known, estimates from below can be used (but these estimates should be greater than -1 too). One of alpha/beta variables (or even both alpha/beta) may be equal to 0, which means than function F(x) is non-singular at A/B. Anyway (singular at bounds or not), function F(x) is supposed to be continuous on (A,B). Fast-convergent algorithm based on a Gauss-Kronrod formula is used. Result is calculated with accuracy close to the machine precision. INPUT PARAMETERS: A, B - interval boundaries (A<B, A=B or A>B) Alpha - power-law coefficient of the F(x) at A, Alpha>-1 Beta - power-law coefficient of the F(x) at B, Beta>-1 OUTPUT PARAMETERS State - structure which stores algorithm state between subsequent calls of AutoGKIteration. Used for reverse communication. This structure should be passed to the AutoGKIteration subroutine. SEE ALSO AutoGKSmooth, AutoGKSmoothW, AutoGKIteration, AutoGKResults. -- ALGLIB -- Copyright 06.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogksingular(double a, double b, double alpha, double beta, ref autogkstate state) { state.wrappermode = 1; state.a = a; state.b = b; state.alpha = alpha; state.beta = beta; state.xwidth = 0.0; state.rstate.ra = new double[10+1]; state.rstate.stage = -1; }
/************************************************************************* Integration of a smooth function F(x) on a finite interval [a,b]. This subroutine is same as AutoGKSmooth(), but it guarantees that interval [a,b] is partitioned into subintervals which have width at most XWidth. Subroutine can be used when integrating nearly-constant function with narrow "bumps" (about XWidth wide). If "bumps" are too narrow, AutoGKSmooth subroutine can overlook them. INPUT PARAMETERS: A, B - interval boundaries (A<B, A=B or A>B) OUTPUT PARAMETERS State - structure which stores algorithm state between subsequent calls of AutoGKIteration. Used for reverse communication. This structure should be passed to the AutoGKIteration subroutine. SEE ALSO AutoGKSmooth, AutoGKSingular, AutoGKIteration, AutoGKResults. -- ALGLIB -- Copyright 06.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogksmoothw(double a, double b, double xwidth, ref autogkstate state) { state.wrappermode = 0; state.a = a; state.b = b; state.xwidth = xwidth; state.rstate.ra = new double[10+1]; state.rstate.stage = -1; }
/************************************************************************* Integration of a smooth function F(x) on a finite interval [a,b]. Fast-convergent algorithm based on a Gauss-Kronrod formula is used. Result is calculated with accuracy close to the machine precision. Algorithm works well only with smooth integrands. It may be used with continuous non-smooth integrands, but with less performance. It should never be used with integrands which have integrable singularities at lower or upper limits - algorithm may crash. Use AutoGKSingular in such cases. INPUT PARAMETERS: A, B - interval boundaries (A<B, A=B or A>B) OUTPUT PARAMETERS State - structure which stores algorithm state between subsequent calls of AutoGKIteration. Used for reverse communication. This structure should be passed to the AutoGKIteration subroutine. SEE ALSO AutoGKSmoothW, AutoGKSingular, AutoGKIteration, AutoGKResults. -- ALGLIB -- Copyright 06.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogksmooth(double a, double b, ref autogkstate state) { autogksmoothw(a, b, 0.0, ref state); }
/************************************************************************* Adaptive integration results Called after AutoGKIteration returned False. Input parameters: State - algorithm state (used by AutoGKIteration). Output parameters: V - integral(f(x)dx,a,b) Rep - optimization report (see AutoGKReport description) -- ALGLIB -- Copyright 14.11.2007 by Bochkanov Sergey *************************************************************************/ public static void autogkresults(autogkstate state, out double v, out autogkreport rep) { v = 0; rep = new autogkreport(); autogk.autogkresults(state.innerobj, ref v, rep.innerobj); return; }
/************************************************************************* This function is used to launcn iterations of ODE solver It accepts following parameters: diff - callback which calculates dy/dx for given y and x obj - optional object which is passed to diff; can be NULL -- ALGLIB -- Copyright 07.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogkintegrate(autogkstate state, integrator1_func func, object obj) { if( func==null ) throw new alglibexception("ALGLIB: error in 'autogkintegrate()' (func is null)"); while( alglib.autogkiteration(state) ) { if( state.needf ) { func(state.innerobj.x, state.innerobj.xminusa, state.innerobj.bminusx, ref state.innerobj.f, obj); continue; } throw new alglibexception("ALGLIB: unexpected error in 'autogksolve'"); } }
/************************************************************************* This function provides reverse communication interface Reverse communication interface is not documented or recommended to use. See below for functions which provide better documented API *************************************************************************/ public static bool autogkiteration(autogkstate state) { bool result = autogk.autogkiteration(state.innerobj); return result; }
/************************************************************************* Integration of a smooth function F(x) on a finite interval [a,b]. This subroutine is same as AutoGKSmooth(), but it guarantees that interval [a,b] is partitioned into subintervals which have width at most XWidth. Subroutine can be used when integrating nearly-constant function with narrow "bumps" (about XWidth wide). If "bumps" are too narrow, AutoGKSmooth subroutine can overlook them. INPUT PARAMETERS: A, B - interval boundaries (A<B, A=B or A>B) OUTPUT PARAMETERS State - structure which stores algorithm state SEE ALSO AutoGKSmooth, AutoGKSingular, AutoGKResults. -- ALGLIB -- Copyright 06.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogksmoothw(double a, double b, double xwidth, autogkstate state) { alglib.ap.assert(math.isfinite(a), "AutoGKSmoothW: A is not finite!"); alglib.ap.assert(math.isfinite(b), "AutoGKSmoothW: B is not finite!"); alglib.ap.assert(math.isfinite(xwidth), "AutoGKSmoothW: XWidth is not finite!"); state.wrappermode = 0; state.a = a; state.b = b; state.xwidth = xwidth; state.needf = false; state.rstate.ra = new double[10+1]; state.rstate.stage = -1; }
/************************************************************************* Integration on a finite interval [A,B]. Integrand have integrable singularities at A/B. F(X) must diverge as "(x-A)^alpha" at A, as "(B-x)^beta" at B, with known alpha/beta (alpha>-1, beta>-1). If alpha/beta are not known, estimates from below can be used (but these estimates should be greater than -1 too). One of alpha/beta variables (or even both alpha/beta) may be equal to 0, which means than function F(x) is non-singular at A/B. Anyway (singular at bounds or not), function F(x) is supposed to be continuous on (A,B). Fast-convergent algorithm based on a Gauss-Kronrod formula is used. Result is calculated with accuracy close to the machine precision. INPUT PARAMETERS: A, B - interval boundaries (A<B, A=B or A>B) Alpha - power-law coefficient of the F(x) at A, Alpha>-1 Beta - power-law coefficient of the F(x) at B, Beta>-1 OUTPUT PARAMETERS State - structure which stores algorithm state SEE ALSO AutoGKSmooth, AutoGKSmoothW, AutoGKResults. -- ALGLIB -- Copyright 06.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogksingular(double a, double b, double alpha, double beta, autogkstate state) { alglib.ap.assert(math.isfinite(a), "AutoGKSingular: A is not finite!"); alglib.ap.assert(math.isfinite(b), "AutoGKSingular: B is not finite!"); alglib.ap.assert(math.isfinite(alpha), "AutoGKSingular: Alpha is not finite!"); alglib.ap.assert(math.isfinite(beta), "AutoGKSingular: Beta is not finite!"); state.wrappermode = 1; state.a = a; state.b = b; state.alpha = alpha; state.beta = beta; state.xwidth = 0.0; state.needf = false; state.rstate.ra = new double[10+1]; state.rstate.stage = -1; }
/************************************************************************* * Integration of a smooth function F(x) on a finite interval [a,b]. * * Fast-convergent algorithm based on a Gauss-Kronrod formula is used. Result * is calculated with accuracy close to the machine precision. * * Algorithm works well only with smooth integrands. It may be used with * continuous non-smooth integrands, but with less performance. * * It should never be used with integrands which have integrable singularities * at lower or upper limits - algorithm may crash. Use AutoGKSingular in such * cases. * * INPUT PARAMETERS: * A, B - interval boundaries (A<B, A=B or A>B) * * OUTPUT PARAMETERS * State - structure which stores algorithm state between subsequent * calls of AutoGKIteration. Used for reverse communication. * This structure should be passed to the AutoGKIteration * subroutine. * * SEE ALSO * AutoGKSmoothW, AutoGKSingular, AutoGKIteration, AutoGKResults. * * * -- ALGLIB -- * Copyright 06.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogksmooth(double a, double b, ref autogkstate state) { autogksmoothw(a, b, 0.0, ref state); }
/************************************************************************* Adaptive integration results Called after AutoGKIteration returned False. Input parameters: State - algorithm state (used by AutoGKIteration). Output parameters: V - integral(f(x)dx,a,b) Rep - optimization report (see AutoGKReport description) -- ALGLIB -- Copyright 14.11.2007 by Bochkanov Sergey *************************************************************************/ public static void autogkresults(autogkstate state, ref double v, autogkreport rep) { v = 0; v = state.v; rep.terminationtype = state.terminationtype; rep.nfev = state.nfev; rep.nintervals = state.nintervals; }
/************************************************************************* Integration of a smooth function F(x) on a finite interval [a,b]. This subroutine is same as AutoGKSmooth(), but it guarantees that interval [a,b] is partitioned into subintervals which have width at most XWidth. Subroutine can be used when integrating nearly-constant function with narrow "bumps" (about XWidth wide). If "bumps" are too narrow, AutoGKSmooth subroutine can overlook them. INPUT PARAMETERS: A, B - interval boundaries (A<B, A=B or A>B) OUTPUT PARAMETERS State - structure which stores algorithm state SEE ALSO AutoGKSmooth, AutoGKSingular, AutoGKResults. -- ALGLIB -- Copyright 06.05.2009 by Bochkanov Sergey *************************************************************************/ public static void autogksmoothw(double a, double b, double xwidth, out autogkstate state) { state = new autogkstate(); autogk.autogksmoothw(a, b, xwidth, state.innerobj); return; }