Numerical integration/Adaptive Simpson's method: Difference between revisions

|-

|

m := (a + b) / 2

fm := f(m)

h := b - a

delta := left + right - whole

tol' := tol / 2

'''if''' depth <= 0 ''or'' tol' == tol ''or'' abs(delta) <= 15 * tol:

'''else''':

'''procedure''' quad_asr(f, a, b, tol, depth)

fa := f(a)

fb := f(b)

|}

 

Simpson's integration of sine from 0 to 1 = 0.459697694

</pre>

 

=={{header|ALGOL 68}}==

<syntaxhighlight lang="algol68">

 

PROC quad asr = ( PROC(REAL)REAL f, REAL a, b, eps )REAL:

<pre>

Simpson's integration of sine from 0.000 to 1.000 = 0.459698

</pre>

 

quadrature_by_adaptive_simpson (f, a, b, tol, depth) =

let

typedef real = g0float tk

 

(* In ATS, you can nest functions inside functions to whatever

depth you like. *)

fn

fa : real,

b : real,

val h = b - a

in

end

 

run out of stack space, etc.). *)

.<depth>.

fa : real,

b : real,

perhaps it is good as documentation. In some instances it

is REALLY what you want. *)

 

val delta = left + right - whole

else

let

lm, flm, depth - 1)

rm, frm, depth - 1)

in

val @(fa, fb) = @(f(a), f(b))

 

in

end

 

estimate of ∫ sin x dx from 0 to 1, by call to a compiled function: 0.459698

estimate of ∫ sin x dx from 0 to 1, by call to the template: 0.459698</pre>

 

=={{header|C}}==

Simpson's integration of sine from 0 to 1 = 0.459698

</pre>

 

=={{header|Common Lisp}}==

;; is no need to return them explicitly as a data structure

;; (though that also could be done).

 

(defun %%quad-asr (f a fa b fb tol whole m fm depth)

auto h = b - a;

return tuple!("m", "fm", "quadval")

}

 

Simpson's rule integration of sin from 0 to 1 is: 0.4596976941573994

</pre>

 

=={{header|Go}}==

Simpson's integration of sine from 0 to 1 = 0.459698

</pre>

 

=={{header|J}}==

Simpson's rule integration of sin from 0 to 1 is: 0.45969769415739936

</pre>

 

=={{header|Kotlin}}==

(0.45969769413186023) // reference value

</syntaxhighlight>

 

=={{header|Nim}}==

type Func = float -> float

 

## Evaluates the Simpson's Rule, also returning m and f(m) to reuse

result.m = (a + b) / 2

result.val = abs(b - a) * (fa + 4 * result.fm + fb) / 6

 

## Efficient recursive implementation of adaptive Simpson's rule.

## Function values at the start, middle, end of the intervals are retained.

f.quadAsr(m, fm, b, fb, eps / 2, right, rm, frm)

 

## Integrate f from a to b using Adaptive Simpson's Rule with max error of eps.

let fa = f(a)

{{out}}

<pre>Simpson's integration of sine from 0 to 1 = 0.4596976941317859</pre>

 

=={{header|OCaml}}==

let fm = f m in

let h = b -. a in

in

let rec _quad_asr a fa b fb tol whole m fm depth =

<pre>$ ocaml adaptive_simpson_task.ml

estimated definite integral of sin(x) for x from 0 to 1: 0.459697694132</pre>

 

=={{header|Perl}}==

<pre>

Simpson's integration of sine from 0 to 1 = 0.459698

</pre>

 

{{out}}

<pre>Simpson's integration of sine from 0 to 1 = 0.459697694</pre>

 

=={{header|REXX}}==

 

=={{header|Scheme}}==

 

<syntaxhighlight lang="scheme">

;; once. There is no need to return them explicitly as

;; a data structure (though that also could be done).

(%%quad-asr

(lambda (a fa b fb tol whole m fm depth)

<pre>$ gsi adaptive_simpson_task.scm

estimated definite integral of sin(x) for x from 0 to 1: .4596976941317858</pre>

 

=={{header|Sidef}}==

Simpson's integration of sine from 0 to 1 ≈ 0.45969769413186

</pre>

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-fmt}}

 

/* "structured" adaptive version, translated from Racket */