Numerical integration: Difference between revisions

sum1 := sum1 + f(a + h * i + h/2)

sum2 := sum2 + f(a + h * i)

''answer'' := (h / 6) * (f(a) + f(b) + 4*sum1 + 2*sum2)

|}

 

Demonstrate your function by showing the results for:

 

<br/>

 

<br/>

 

=={{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}}==

 

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

test integrators( "x ", ( LONG REAL x )LONG REAL: x, 0, 6 000, 6 000 000 );

 

{{out}}

<pre>

x 12499997.500000 12500002.500000 12500000.000000 12500000.000000 12500000.000000

x 17999997.000000 18000003.000000 18000000.000000 18000000.000000 18000000.000000</pre>

 

=={{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

 

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|Chapel}}==

proc f1(x:real):real {

return x**3;

writeln("simpsonsIntegration: calculated = ", calculated, "; exact = ", exact, "; difference = ", abs(calculated - exact));

writeln();

output

f(x) = x**3 with 100 steps from 0 to 1

leftRectangleIntegration: calculated = 0.245025; exact = 0.25; difference = 0.004975

trapezoidIntegration: calculated = 1.8e+07; exact = 1.8e+07; difference = 3.72529e-09

simpsonsIntegration: calculated = 1.8e+07; exact = 1.8e+07; difference = 0.0

=={{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|Comal}}==

{{works with|OpenComal on Linux}}

1000 PRINT "F(X)";" FROM";" TO";" L-Rect";" M-Rect";" R-Rect ";" Trapez";" Simpson"

1010 fromval:=0

1920 RETURN x

1930 ENDFUNC

{{out}}

<pre>

=={{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|Elixir}}==

@funs ~w(leftrect midrect rightrect trapezium simpson)a

f4 = fn x -> x end

IO.puts "\nf(x) = x, where x is [0,6000], with 6,000,000 approximations."

 

{{out}}

 

=={{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|FreeBASIC}}==

Based on the BASIC entry and the BBC BASIC entry

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>function range steps leftrect midrect rightrect trap simpson

 

=={{header|Go}}==

 

import (

fmt.Println("")

}

{{out}}

<pre>

=={{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:

 

:: Fractional a

=> (a1 -> a) -> [a1] -> [a] -> a

integrations

where

{{Out}}

<pre>f(x) = x^3 [0.0,1.0] (100 approximations)

=={{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|Julia}}==

{{works with|Julia|0.6}}

 

h = (b - a) / n

s = f(a + h / 2)

simpson(x -> x, 0, 6000, 6_000_000)

 

 

{{out}}

 

=={{header|Kotlin}}==

 

typealias Func = (Double) -> Double

integrate(0.0, 5000.0, 5_000_000) { it }

integrate(0.0, 6000.0, 6_000_000) { it }

 

{{out}}

Simpson = 18000000.000000

</pre>

 

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

while 1

read x$

 

end

 

Numerical integration

 

=={{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

 

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|Nim}}==

{{trans|Python}}

type Rule = proc(f: Function; x, h: float): float

 

 

proc cube(x: float): float =

 

proc reciprocal(x: float): float =

proc integrate(f: Function; a, b: float; steps: int; meth: Rule): float =

let h = (b-a) / float(steps)

result += meth(f, a+float(i)*h, h)

result = h * result

echo fName, " integrated using ", rName

echo " from ", a, " to ", b, " (", steps, " steps) = ",

<pre>cube integrated using leftRect

cube integrated using midRect

cube integrated using rightRect

cube integrated using trapezium

cube integrated using simpson

reciprocal integrated using leftRect

reciprocal integrated using midRect

reciprocal integrated using rightRect

reciprocal integrated using trapezium

reciprocal integrated using simpson

identity integrated using leftRect

identity integrated using midRect

identity integrated using rightRect

identity integrated using trapezium

identity integrated using simpson

identity integrated using leftRect

identity integrated using midRect

identity integrated using rightRect

identity integrated using trapezium

identity integrated using simpson

 

=={{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

 

=={{header|Perl}}==

 

sub leftrect {

say for integrate('1 / $_', 1, 100, 1000, log(100)); say '';

say for integrate('$_', 0, 5_000, 5_000_000, 12_500_000); say '';

{{out}}

<pre>$_ ** 3

 

$_

in [0..6000] / 6000000

exact result: 18000000

 

=={{header|Phix}}==

{{out}}

<pre>

x 0 - 6000 6000000 17999997 18000000 18000003 18000000 18000000

</pre>

 

=={{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

h = (b-a)/float(steps)

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}}==

numeric digits 20 /*use twenty decimal digits precision. */

 

if test==1 then do; L= 0; H= 1; i= 100; end

if test==2 then do; L= 1; H= 100; i= 1000; end

if test==3 then do; L= 0; H= 5000; i= 5000000; end

end /*test*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

return $*h/1

/*──────────────────────────────────────────────────────────────────────────────────────*/

return $*h/1

/*──────────────────────────────────────────────────────────────────────────────────────*/

return $*h/1

/*──────────────────────────────────────────────────────────────────────────────────────*/

 

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

 

 

</pre>

 

=={{header|Ring}}==

# Project : Numerical integration

 

eval("result = " + x2)

return (d / 6) * (f + result + 4 * s1 + 2 * s)

Output:

<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|Rust}}==

This is a partial solution and only implements trapezium integration.

where F: Fn(f64) -> f64

{

println!("{}", integral(|x| x, 0.0..5000.0, 5_000_000));

println!("{}", integral(|x| x, 0.0..6000.0, 6_000_000));

 

{{out}}

 

=={{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|SequenceL}}==

import <Utilities/Sequence.sl>;

 

delimit(delimit(heading ++ transpose(funcs ++ ranges ++ trimEndZeroes(floatToString(tests, 8))), '\t'), '\n');

 

 

{{out}}

x 0 - 6000 17999997. 18000003. 18000000. 18000000. 18000000."

</pre>

 

=={{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 )

 

=={{header|Stata}}==

function integrate(f,a,b,n,u,v) {

s = 0

test(&id(),0,5000,5000000)

test(&id(),0,6000,6000000)

 

'''Output'''

 

=={{header|Swift}}==

case rectangularLeft

case rectangularRight

print("f(x) = 1 / x:", types.map({ integrate(from: 1, to: 100, n: 1000, using: $0, f: { 1 / $0 }) }))

print("f(x) = x, 0 -> 5_000:", types.map({ integrate(from: 0, to: 5_000, n: 5_000_000, using: $0, f: { $0 }) }))

 

{{out}}

 

=={{header|Tcl}}==

 

proc leftrect {f left right} {

puts [format " %-10s %s\t(%.1f%%)" $method $int $diff]

}

<pre>integral of square(x) from 0 to 3.141592653589793 in 10 steps

leftrect 8.836788853885448 (-14.5%)

the integrand <math>f</math>, the bounds <math>(a,b)</math>, and the number of intervals <math>n</math>.

 

#import nat

#import flo

(integral_by "m") ("f","a","b","n") =

 

An alternative way of defining this function shown below prevents redundant evaluations of the integrand

at the cost of building a table-driven finite map in advance.

 

As mentioned in the Haskell solution, the latter choice is preferable if evaluating the integrand

is expensive.

An integrating function is defined for each method as follows.

right = integral_by "f". ("l","r"). "f" "r"

midpoint = integral_by "f". ("l","r"). "f" div\2. plus/"l" "r"

trapezium = integral_by "f". ("l","r"). div\2. plus "f"~~/"l" "r"

As shown above, the method passed to the <code>integral_by</code> function

is itself a higher order function taking an integrand <math>f</math> as an argument and

Here is a test program showing the results of integrating the square from zero to <math>\pi</math> in ten intervals

by all five methods.

 

output:

<pre>

The following program does not follow the task requirement on two points: first, the same function is used for all quadrature methods, as they are really the same thing with different parameters (abscissas and weights). And since it's getting rather slow for a large number of intervals, the last two are integrated with resp. 50,000 and 60,000 intervals. It does not make sense anyway to use more, for such a simple function (and if really it were difficult to integrate, one would rely one more sophistcated methods).

 

Option Base 1

 

Next j

Next i

 

=={{header|XPL0}}==

 

func real Func(FN, X); \Return F(X) for function number FN

Integrate(0.0, 5000.0, 3, 5_000_000);

Integrate(0.0, 6000.0, 3, 6_000_000);

 

Interestingly, the small rounding errors creep in when millions of

17999997.001391 18000003.001391 18000000.001391 18000000.001391 18000000.001391

</pre>

 

=={{header|zkl}}==

{{trans|D}}

h:=(b - a) / steps;

h*(0).reduce(steps,'wrap(s,i){ F(f, h*i + a, h) + s },0.0);

"%s %f".fmt(nm,integrate(f,a.xplode())).println() }, fs);

println();

{{out}}

<pre>