DEV Community

Maria Ines Montenegro
Maria Ines Montenegro

Posted on • Edited on

Trapezoidal Rule in F#

#numericalmethods #programming

Numerical is approximate; analytical is exact.

A numerical method is a tool used to find a numerical solution to a problem which can be difficult to solve analytically.

Mostly done by computers, this approach is a complete set of instructions that are executed in order to find a solution. With this being said,
the Trapezoidal Rule is a numerical method used to find definite integrals. The most common application for this method is to find the
area under a function in a given set of intervals. Finding this area is typically done using Riemann sums, but this method proves to be more exact because it uses trapezoids instead of rectangles.

Trapezoidal Rule

  • Reimann sum Trapezoidal Rule
  • Trapezoidal Rule

In this case, I implemented this numerical method using F# which is a functional programming language. First, I chose the function to integrate; in this case sin(x):



let f x = System.Math.Sin(x)
Enter fullscreen mode Exit fullscreen mode

The algorithm has to receive the intervals (a,b) through which it will find the area and a number (N) of trapezoids to form.
With these parameters, it can now calculate the length of each trapezoid:



let h = (b - a)/N
Enter fullscreen mode Exit fullscreen mode

Trapezoidal Rule

The formula for this method is the following:
TrapezoidalFormula

I created two functions in order to calculate the formula above:



let rec sum_recursive (xi:float) (h:float) f (N:float) (iter:float) =
    if iter = N then
      xi
    else
      let xi_1 = xi + h*f(h*iter)
      sum_recursive xi_1 h f N (iter+1.0)

let trapezoidal (a:float) (b:float) f (N:float) =
      let h = (b - a)/N
      let left_side = h/2.0*(f(a)+f(b))
      left_side + sum_recursive 0.0 h f N 0.0
Enter fullscreen mode Exit fullscreen mode

This method can be used for things like: finding how much fluid is flowing through a specific area, calculating the work needed to move an object at a certain speed, or even finding the center of mass of an object.

Overall, learning to program a numerical method has enabled me to relate mathematical concepts, that are normally just seen in class; with programming, which is something I actually use in my day to day life. Furthermore, this was also my first time working with a functional programming language such as F#; which I ended up enjoying.

Here's my complete code
Hope you find it useful!

References

Understanding the trapezoidal rule
Trapezoidal Rule
How to approximate area with the trapezoid rule

Top comments (4)

Collapse
 
bohdanstupak1 profile image
Bohdan Stupak •

Great job but I'm not sure why using functional-first language to use it OO-style. To me using mutable in F# is a flag that something is done in a non-functional fashion.
How about considering the code below?

let trapezoidal2 a b N = 
    let h = (b - a)/N
    let initialAccValue = h/2.0*(f(a)+f(b))
    [|1 .. System.Convert.ToInt32(N)|]
    |> Array.mapi(fun i x -> i+1,x)
    |> Array.fold (fun acc (i,_) -> acc + h*f(float(i)*h+a)) initialAccValue

The key tricks here are Array.mapi which allows us to work with tuple (element,index) instead of just an element; and substitution of iterative increment of xi by h to multiplication index*h+a

Collapse
 
marinesm profile image
Maria Ines Montenegro • • Edited

Since this was my first time with a functional programming language I think I hadn't fully grasped the concepts. I ended up using recursion in order to remove the mutable variables; which I updated in my post. Thank you very much for your feedback!

Collapse
 
campbellashleym profile image
Ashley M Campbell • • Edited

This is so true. The more trapezoids you use the more exact the integral tends to be. Also, it is very simple to use compared to other methods. Great article!

Collapse
 
samsung1996 profile image
samantha •

Really cool approach

Read next

jwilliamsr profile image

Deploying AI Projects Through a Jenkins Pipeline

Jesse Williams -

nenepo profile image

Optimizing React Re-Renders: Best Practices for Performance

Nenepo -

koolkamalkishor profile image

Evaluating Medical Retrieval-Augmented Generation (RAG) with NVIDIA AI Endpoints and Ragas

KAMAL KISHOR -

labby profile image

Ethical Hacking | FTP Vulnerability Exploitation

Labby -