Numerical integration: Difference between revisions

{{task|Arithmetic operations}}

 

 

 

 

Demonstrate your function by showing the results for:

 

 

=={{header|ActionScript}}==

Integration functions:

{

var sum:Number = 0;

}

return (dx/6) * (f(a) + f(b) + 4*sum1 + 2*sum2);

Usage:

return (2/(1+ 4*(n*n)));

}

trace(trapezium(f1, -1, 2 ,4 ));

trace(simpson(f1, -1, 2 ,4 ));

=={{header|Ada}}==

Specification of a generic package implementing the five specified kinds of numerical integration:

type Scalar is digits <>;

with function F (X : Scalar) return Scalar;

function Trapezium (A, B : Scalar; N : Positive) return Scalar;

function Simpsons (A, B : Scalar; N : Positive) return Scalar;

An alternative solution is to pass a function reference to the integration function. This solution is probably slightly faster, and works even with Ada83. One could also make each integration function generic, instead of making the whole package generic.

 

Body of the package implementing numerical integration:

function Left_Rectangular (A, B : Scalar; N : Positive) return Scalar is

H : constant Scalar := (B - A) / Scalar (N);

Sum : Scalar := F(A) + F(B);

X : Scalar := 1.0;

while X <= Scalar (N) - 1.0 loop

Sum := Sum + 2.0 * F (A + X * (B - A) / Scalar (N));

function Simpsons (A, B : Scalar; N : Positive) return Scalar is

H : constant Scalar := (B - A) / Scalar (N);

begin

end loop;

end Simpsons;

 

Test driver:

with Integrate;

 

end X;

end Numerical_Integration;

 

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

 

###############

h / 6 * (f(a) + f(b) + 4 * sum1 + 2 * sum2)

END # simpson #;

 

=={{header|AutoHotkey}}==

ahk [http://www.autohotkey.com/forum/viewtopic.php?t=44657&postdays=0&postorder=asc&start=139 discussion]

MsgBox % Rect("fun", 0, 1, 10) ; 0.50 mid

MsgBox % Rect("fun", 0, 1, 10, 1) ; 0.55 right

fun(x) { ; linear test function

Return x

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

{{trans|Java}}

h = (b - a) / n

sum = 0

h = (b - a) / n

sum = 0

NEXT x

midRect = sum

 

FOR i = 0 TO n-1

NEXT i

 

 

simpson = h / 6 * (f(a) + f(b) + 4 * sum1 + 2 * sum2)

 

=={{header|BBC BASIC}}==

@% = 12 : REM Column width

NEXT

x = a

'''Output:'''

<pre>

 

=={{header|C}}==

#include <stdlib.h>

#include <math.h>

 

return h / 6.0 * (func(from) + func(to) + 4.0 * sum1 + 2.0 * sum2);

 

double f3(double x)

{

printf("\n");

}

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Linq;

TestApproximationMethods(new DefiniteIntegral(x => x, new Interval(0, 6000)), 6000000);

}

Output:

0.24999999875

0.2500500025

18000003

18000000

=={{header|C++}}==

 

Due to their similarity, it makes sense to make the integration method a policy.

template<typename Method, typename F, typename Float>

double integrate(F f, Float a, Float b, int steps, Method m)

double rr = integrate(f, 0.0, 1.0, 10, rectangular(rectangular::right));

double t = integrate(f, 0.0, 1.0, 10, trapezium());

 

=={{header|CoffeeScript}}==

{{trans|python}}

rules =

left_rect: (f, x, h) -> f(x)

result = integrate func, a, b, steps, rule

console.log rule_name, result

output

> coffee numerical_integration.coffee

-- tests for cube with 100 steps from 0 to 1

trapezium 17999999.999999993

simpson 17999999.999999993

 

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

 

(* d (loop for x from a below b by d summing (funcall f x))))

 

(funcall f b)

(* 4 sum1)

 

=={{header|D}}==

 

template integrate(alias method) {

writeln();

}

Output:

<pre>rectangular left: 0.202500

===A faster version===

This version avoids function pointers and delegates, same output:

 

template integrate(alias method) {

writeln();

}

 

=={{header|E}}==

 

{{trans|Python}}

 

 

def leftRect(f, x, h) {

def h := (b-a) / steps

return h * accum 0 for i in 0..!steps { _ + meth(f, a+i*h, h) }

# value: 105.33333333333334

 

? integrate(fn x { x ** 9 }, 0, 1, 300, simpson)

 

=={{header|Euphoria}}==

atom h, sum

h = (bounds[2]-bounds[1])/n

? int_rightrect({0,10},1000,routine_id("x"))

? int_midrect({0,10},1000,routine_id("x"))

 

Output:

50

</pre>

 

=={{header|Factor}}==

USE: math.functions

IN: scratchpad 0 1 [ 3 ^ ] integrate-simpson .

IN: scratchpad 6000000 num-steps set-global

IN: scratchpad 0 6000 [ ] integrate-simpson .

 

=={{header|Forth}}==

 

defer method ( fn F: x -- fn[x] )

test mid fn2 \ 2.496091

test trap fn2 \ 2.351014

 

=={{header|Fortran}}==

In ISO Fortran 95 and later if function f() is not already defined to be "elemental", define an elemental wrapper function around it to allow for array-based initialization:

real :: elemf, x

elemf = f(x)

 

Use Array Initializers, Pointers, Array invocation of Elemental functions, Elemental array-array and array-scalar arithmetic, and the SUM intrinsic function. Methods are collected into a single function in a module.

implicit none

 

end function integrate

 

 

Usage example:

use Integration

use FunctionHolder

print *, integrate(afun, 0., 3**(1/3.), method='trapezoid')

 

 

The FunctionHolder module:

 

implicit none

end function afun

=={{header|Go}}==

 

import (

spec{0, 6000, 6e6, 18e6, "x", func(x float64) float64 { return x }},

}

// object for associating a printable function name with an integration method

type method struct {

name string

integrate func(spec) float64

// integration methods implemented per task description

var methods = []method{

method{"Simpson's ", simpson},

}

func rectLeft(t spec) float64 {

r := t.upper - t.lower

nf := float64(t.n)

x0 := t.lower

x1 := t.lower + float64(i+1)*r/nf

// x1-x0 better than r/nf.

// (with r/nf, the represenation error accumulates)

x0 = x1

}

}

 

func rectRight(t spec) float64 {

r := t.upper - t.lower

nf := float64(t.n)

x0 := t.lower

x1 := t.lower + float64(i+1)*r/nf

x0 = x1

}

}

 

func rectMid(t spec) float64 {

r := t.upper - t.lower

nf := float64(t.n)

// as well. we just need one extra point, so we use lower-.5.

x0 := t.lower - .5*r/nf

x1 := t.lower + (float64(i)+.5)*r/nf

x0 = x1

}

}

 

func trap(t spec) float64 {

r := t.upper - t.lower

nf := float64(t.n)

x0 := t.lower

f0 := t.f(x0)

x1 := t.lower + float64(i+1)*r/nf

f1 := t.f(x1)

x0, f0 = x1, f1

}

}

 

func simpson(t spec) float64 {

r := t.upper - t.lower

nf := float64(t.n)

// we play a little loose with the values used for dx and dx0.

dx0 := r / nf

x0 := t.lower + dx0

for i := 1; i < t.n; i++ {

xmid := (x0 + x1) * .5

dx := x1 - x0

x0 = x1

}

}

 

func sum(v []float64) float64 {

}

func main() {

for _, t := range data {

fmt.Println("")

}

<pre>

Integration from 0 to 1 in 100 parts

Exact result 2.5000000e-01 Error

=={{header|Groovy}}==

Solution:

assert (bounds.size() == 2) && (bounds[0] instanceof Double) && (bounds[1] instanceof Double) && (nRect > 0)

}

h/3*((fLeft + fRight).sum() + 4*(fMid.sum()))

}

 

Test:

 

Each "nRect" (number of rectangles) value given below is the minimum value that meets the tolerance condition for the given circumstances (function-to-integrate, integral-type and integral-bounds).

 

double sinIntegralCalculated = -(Math.cos(Math.PI) - Math.cos(0d))

assert ((simpsonsIntegral([0d, Math.PI], 1, cubicPoly) - cpIntegralCalc0ToPI)/ cpIntegralCalc0ToPI).abs() < tolerance**2.75 // 1 in 100 billion

double cpIntegralCalcMinusEToPI = (cubicPolyAntiDeriv(Math.PI) - cubicPolyAntiDeriv(-Math.E))

 

Requested Demonstrations:

println ([" LeftRect": leftRectIntegral([0d, 1d], 100) { it**3 }])

println (["RightRect": rightRectIntegral([0d, 1d], 100) { it**3 }])

println (["Trapezoid": trapezoidIntegral([0d, 6000d], 6000000) { it }])

println ([" Simpsons": simpsonsIntegral([0d, 6000d], 6000000) { it }])

 

Output:

Different approach from most of the other examples: First, the function ''f'' might be expensive to calculate, and so it should not be evaluated several times. So, ideally, we want to have positions ''x'' and weights ''w'' for each method and then just calculate the approximation of the integral by

 

 

Second, let's to generalize all integration methods into one scheme. The methods can all be characterized by the coefficients ''vs'' they use in a particular interval. These will be fractions, and for terseness, we extract the denominator as an extra argument ''v''.

Now there are the closed formulas (which include the endpoints) and the open formulas (which exclude them). Let's do the open formulas first, because then the coefficients don't overlap:

integrateOpen v vs f a b n = approx f xs ws * h / v where

m = fromIntegral (length vs) * n

ws = concat $ replicate n vs

c = a + h/2

 

Similarly for the closed formulas, but we need an additional function ''overlap'' which sums the coefficients overlapping at the interior interval boundaries:

integrateClosed v vs f a b n = approx f xs ws * h / v where

m = fromIntegral (length vs - 1) * n

inter n [] = x : inter (n-1) xs

inter n [y] = (x+y) : inter (n-1) xs

 

And now we can just define

 

intRightRect = integrateClosed 1 [0,1]

intMidRect = integrateOpen 1 [1]

intTrapezium = integrateClosed 2 [1,1]

 

or, as easily, some additional schemes:

 

intOpen1 = integrateOpen 2 [3,3]

 

Some examples:

The whole program:

 

 

 

 

 

uncurry4 f ~(a, b, c, d) = f a b c d

 

 

 

 

 

 

Runtime: about 7 seconds.

 

=={{header|J}}==

===Solution:===

'a b steps'=. 3{.y,128

size=. (b - a)%steps

trapezium=: adverb def '-: +/ u y'

 

===Example usage===

====Required Examples====

It=: trapezium integrate

Is=: simpson integrate

1.8e7

] Is 0 6000 6e6

====Older Examples====

Integrate <code>square</code> (<code>*:</code>) from 0 to &pi; in 10 steps using various methods.

10.3095869962

*: trapezium integrate 0 1p1 10

10.3871026879

*: simpson integrate 0 1p1 10

Integrate <code>sin</code> from 0 to &pi; in 10 steps using various methods.

sin rectangle integrate 0 1p1 10

2.00824840791

1.98352353751

sin simpson integrate 0 1p1 10

===Aside===

Note that J has a primitive verb <code>p..</code> for integrating polynomials. For example the integral of <math>x^2</math> (which can be described in terms of its coefficients as <code>0 0 1</code>) is:

0 0 0 0.333333333333

0 p.. 0 0 1x NB. or using rationals

That is: <math>0x^0 + 0x^1 + 0x^2 + \tfrac{1}{3}x^3</math><br>

So to integrate <math>x^2</math> from 0 to &pi; :

 

That said, J also has <code>d.</code> which can [http://www.jsoftware.com/help/dictionary/dddot.htm integrate] suitable functions.

 

 

=={{header|Java}}==

{

 

}

}

 

=={{header|Liberty BASIC}}==

while 1

read x$

 

end

 

Numerical integration

Trapezium method 18000000.0000000000 diff 0 0 %

Simpson's Rule 18000000.0000000000 diff 0 0 %

 

=={{header|Logo}}==

output invoke :fn :x

end

print integrate "i.mid "fn2 4 -1 2 ; 2.496091

print integrate "i.trapezium "fn2 4 -1 2 ; 2.351014

=={{header|Lua}}==

local h = (b - a) / n

local x = a

print( int_methods[i]( function(x) return x end, 0, 5000, 5000000 ) )

print( int_methods[i]( function(x) return x end, 0, 6000, 6000000 ) )

 

Module[{sum = 0, dx = (b - a)/N, x = a, n = N} ,

For[n = N, n > 0, n--, x += dx; sum += f[x];];

For[n = 1, n < N, n++, sum1 += f[a + dx*n + dx/2];

sum2 += f[a + dx*n];];

<pre>f[x_] := x^3

g[x_] := 1/x

{12500003., 12500008., 12500005., 12500000., 12500000.},

{18000003., 18000009., 18000006., 18000000., 18000000.}}</pre>

=={{header|MATLAB}} / {{header|Octave}}==

 

 

Function for performing left rectangular integration: leftRectIntegration.m

 

format long;

integral = width * sum( f(x(1:n-1)) );

 

Function for performing right rectangular integration: rightRectIntegration.m

 

format long;

integral = width * sum( f(x(2:n)) );

 

Function for performing mid-point rectangular integration: midPointRectIntegration.m

 

format long;

integral = width * sum( f( (x(1:n-1)+x(2:n))/2 ) );

 

Function for performing trapezoidal integration: trapezoidalIntegration.m

 

format long;

integral = trapz( x,f(x) );

 

 

Using anonymous functions

 

 

ans =

 

 

Using predefined functions

 

Built-in MATLAB function sin(x):

 

ans =

 

 

User defined scripts and functions:

fermiDirac.m

k = 8.617343e-5; %Boltazmann's Constant in eV/K

answer = 1./( 1+exp( (x)/(k*2000) ) ); %Fermi-Dirac distribution with mu = 0 and T = 2000K

 

 

ans =

 

 

=={{header|Maxima}}==

for i from 1 thru n do s: s + subst(x = a + i * h, e),

s * h)$

2 * log(2) - 1 - %, bfloat;

 

 

=={{header|OCaml}}==

The problem can be described as integrating using each of a set of methods, over a set of functions, so let us just build the solution in this modular way.

let h = (b -. a) /. float_of_int steps in

let rec helper i s =

else helper (succ i) (s +. meth f (a +. h *. float_of_int i) h)

in

( "rect_l", fun f x _ -> f x);

( "rect_m", fun f x h -> f (x +. h /. 2.) );

( "trap", fun f x h -> (f x +. f (x +. h)) /. 2. );

( "simp", fun f x h -> (f x +. 4. *. f (x +. h /. 2.) +. f (x +. h)) /. 6. )

( "cubic", (fun x -> x*.x*.x), 0.0, 1.0, 100);

( "recip", (fun x -> 1.0/.x), 1.0, 100.0, 1000);

( "x to 5e3", (fun x -> x), 0.0, 5000.0, 5_000_000);

( "x to 6e3", (fun x -> x), 0.0, 6000.0, 6_000_000)

List.iter (fun (s,f,lo,hi,n) ->

Printf.printf "Testing function %s:\n" s;

Printf.printf " method %s gives %.15g\n" name (integrate f lo hi n meth)

) methods

<pre>

Testing function cubic:

=={{header|PARI/GP}}==

Note also that double exponential integration is available as <code>intnum(x=a,b,f(x))</code> and Romberg integration is available as <code>intnumromb(x=a,b,f(x))</code>.

sum(i=0,n-1,f(a+(b-a)*i/n), 0.)*(b-a)/n

};

test(x->1/x, 1, 100, 1000)

test(x->x, 0, 5000, 5000000)

 

Results:

 

=={{header|Pascal}}==

begin

RectLeft := f(xl)

end;

integrate := integral

 

 

my $h = ($b - $a) / $n;

}

my $h = ($b - $a) / $n;

}

my $h = ($b - $a) / $n;

}

my $h = ($b - $a) / $n;

}

my $h = ($b - $a) / $n;

my $h2 = $h/2;

my $sum2 = 0;

}

}

}

 

 

 

in [0..1] / 100

exact result: 0.25

rectangle method left: 0.245025

rectangle method right: 0.255025

composite trapezoidal rule: 0.250025

quadratic simpsons rule: 0.25

 

in [1..100] / 1000

 

exact result: 12500000

rectangle method mid: 12500000

composite trapezoidal rule: 12500000

quadratic simpsons rule: 12500000

 

exact result: 18000000

rectangle method mid: 18000000

composite trapezoidal rule: 18000000

 

 

=={{header|PicoLisp}}==

 

(de leftRect (Fun X)

(*/ H Sum 1.0) ) )

 

Output:

<pre>105.333</pre>

 

=={{header|PureBasic}}==

 

 

Procedure.d LeftIntegral(Start, Stop, Steps, *func.TestFunction)

Answer$+"Trapezium="+StrD(Trapezium (0,6000,6000000,@Test3()))+#CRLF$

Answer$+"Simpson ="+StrD(Simpson (0,6000,6000000,@Test3()))

<pre>Left =0.2353220100

Mid =0.2401367513

=={{header|Python}}==

Answers are first given using floating point arithmatic, then using fractions, only converted to floating point on output.

 

def left_rect(f,x,h):

print('%s integrated using %s\n from %r to %r (%i steps and fractions) = %r' %

(func.__name__, rule.__name__, a, b, steps,

 

'''Tests'''

for rule in (left_rect, mid_rect, right_rect, trapezium, simpson):

print('%s integrated using %s\n from %r to %r (%i steps) = %r' %

print('%s integrated using %s\n from %r to %r (%i steps and fractions) = %r' %

(func.__name__, rule.__name__, a, b, steps,

 

'''Sample test Output'''

 

A faster Simpson's rule integrator is

a1 = a+h/2

s1 = sum( f(a1+i*h) for i in range(0,steps))

s2 = sum( f(a+i*h) for i in range(1,steps))

 

=={{header|R}}==

 

}

 

}

 

 

 

 

 

=={{header|Racket}}==

#lang racket

(define (integrate f a b steps meth)

(test (λ(x) x) 0. 5000. 5000000 "IDENTITY")

(test (λ(x) x) 0. 6000. 6000000 "IDENTITY")

Output:

CUBED

left-rect: 0.24502500000000005

trapezium: 17999999.999999993

simpson: 17999999.999999993

 

=={{header|REXX}}==

 

 

 

 

 

</pre>

 

=={{header|Ruby}}==

{{trans|Tcl}}

f.call(left)

end

printf " %-10s %s\t(%.1f%%)\n", method, int, diff

end

outputs

<pre>integral of #<Method: Object#square> from 0 to 3.14159265358979 in 10 steps

trapezium 1.98352353750945 (-0.8%)

simpson 2.0000067844418 (0.0%)</pre>

 

=={{header|Scala}}==

def leftRect(f:Double=>Double, a:Double, b:Double)=f(a)

def midRect(f:Double=>Double, a:Double, b:Double)=f((a+b)/2)

print(fn3, 0, 6000, 6000000)

}

Output:

<pre>rectangular left : 0,245025

=={{header|Scheme}}==

 

(define h (/ (- b a) steps))

(* h

(define rr (integrate square 0 1 10 right-rect))

(define t (integrate square 0 1 10 trapezium))

 

=={{header|Standard ML}}==

val h = (b - a) / real steps

fun helper (i, s) =

val rr = integrate (square, 0.0, 1.0, 10, right_rect)

val t = integrate (square, 0.0, 1.0, 10, trapezium )