En el campo del análisis numérico, la regla trapezoidal se usa para encontrar la aproximación de una integral definida. La idea básica de la regla trapezoidal es suponer que la región bajo la gráfica de la función dada es un trapezoide y calcular su área.
De ello se deduce que: ![{\displaystyle \int _{a}^{b}f(x)\,dx\approx (b-a)\left[{\frac {f(a)+f(b)}{2}}\right]}](https://www.geeksforgeeks.org/wp-content/ql-cache/quicklatex.com-b7df47f04551ee6bdcea9030d7ce2b65_l3.png "Rendered by QuickLaTeX.com")
Para obtener resultados más precisos, el dominio del gráfico se divide en n segmentos de igual tamaño, como se muestra a continuación:
Espaciamiento de cuadrícula o tamaño de segmento h = (ba) / n.
Por lo tanto, el valor aproximado de la integral puede estar dado por: ![\int_{a}^{b}f(x)dx=\frac{b-a}{2n}\left [ f(a)+2\left \{ \sum_{i=1}^{n-1}f(a+ih) \right \}+f(b) \right ]](https://www.geeksforgeeks.org/wp-content/ql-cache/quicklatex.com-152221d79e2f501da9f3bdc481362d5c_l3.png "Rendered by QuickLaTeX.com")
C++
// C++ program to implement Trapezoidal rule
#include<stdio.h>
// A sample function whose definite integral's
// approximate value is computed using Trapezoidal
// rule
float y(float x)
{
// Declaring the function f(x) = 1/(1+x*x)
return 1/(1+x*x);
}
// Function to evaluate the value of integral
float trapezoidal(float a, float b, float n)
{
// Grid spacing
float h = (b-a)/n;
// Computing sum of first and last terms
// in above formula
float s = y(a)+y(b);
// Adding middle terms in above formula
for (int i = 1; i < n; i++)
s += 2*y(a+i*h);
// h/2 indicates (b-a)/2n. Multiplying h/2
// with s.
return (h/2)*s;
}
// Driver program to test above function
int main()
{
// Range of definite integral
float x0 = 0;
float xn = 1;
// Number of grids. Higher value means
// more accuracy
int n = 6;
printf("Value of integral is %6.4f\n",
trapezoidal(x0, xn, n));
return 0;
}
Java
// Java program to implement Trapezoidal rule
class GFG
{
// A sample function whose definite
// integral's approximate value
// is computed using Trapezoidal
// rule
static float y(float x)
{
// Declaring the function
// f(x) = 1/(1+x*x)
return 1 / (1 + x * x);
}
// Function to evaluate the value of integral
static float trapezoidal(float a, float b, float n)
{
// Grid spacing
float h = (b - a) / n;
// Computing sum of first and last terms
// in above formula
float s = y(a) + y(b);
// Adding middle terms in above formula
for (int i = 1; i < n; i++)
s += 2 * y( a + i * h);
// h/2 indicates (b-a)/2n. Multiplying h/2
// with s.
return (h / 2) * s;
}
// Driver code
public static void main (String[] args)
{
// Range of definite integral
float x0 = 0;
float xn = 1;
// Number of grids. Higher
// value means more accuracy
int n = 6;
System.out.println("Value of integral is "+
Math.round(trapezoidal(x0, xn, n)
* 10000.0) / 10000.0);
}
}
// This code is contributed by Anant Agarwal.
Python3
# Python3 code to implement Trapezoidal rule
# A sample function whose definite
# integral's approximate value is
# computed using Trapezoidal rule
def y( x ):
# Declaring the function
# f(x) = 1/(1+x*x)
return (1 / (1 + x * x))
# Function to evaluate the value of integral
def trapezoidal (a, b, n):
# Grid spacing
h = (b - a) / n
# Computing sum of first and last terms
# in above formula
s = (y(a) + y(b))
# Adding middle terms in above formula
i = 1
while i < n:
s += 2 * y(a + i * h)
i += 1
# h/2 indicates (b-a)/2n.
# Multiplying h/2 with s.
return ((h / 2) * s)
# Driver code to test above function
# Range of definite integral
x0 = 0
xn = 1
# Number of grids. Higher value means
# more accuracy
n = 6
print ("Value of integral is ",
"%.4f"%trapezoidal(x0, xn, n))
# This code is contributed by "Sharad_Bhardwaj".
C#
// C# program to implement Trapezoidal
// rule.
using System;
class GFG {
// A sample function whose definite
// integral's approximate value
// is computed using Trapezoidal
// rule
static float y(float x)
{
// Declaring the function
// f(x) = 1/(1+x*x)
return 1 / (1 + x * x);
}
// Function to evaluate the value
// of integral
static float trapezoidal(float a,
float b, float n)
{
// Grid spacing
float h = (b - a) / n;
// Computing sum of first and
// last terms in above formula
float s = y(a) + y(b);
// Adding middle terms in above
// formula
for (int i = 1; i < n; i++)
s += 2 * y( a + i * h);
// h/2 indicates (b-a)/2n.
// Multiplying h/2 with s.
return (h / 2) * s;
}
// Driver code
public static void Main ()
{
// Range of definite integral
float x0 = 0;
float xn = 1;
// Number of grids. Higher
// value means more accuracy
int n = 6;
Console.Write("Value of integral is "
+ Math.Round(trapezoidal(x0, xn, n)
* 10000.0) / 10000.0);
}
}
// This code is contributed by nitin mittal.
PHP
<?php
// PHP program to implement Trapezoidal rule
// A sample function whose definite
// integral's approximate value is
// computed using Trapezoidal rule
function y($x)
{
// Declaring the function
// f(x) = 1/(1+x*x)
return 1 / (1 + $x * $x);
}
// Function to evaluate the
// value of integral
function trapezoidal($a, $b, $n)
{
// Grid spacing
$h = ($b - $a) / $n;
// Computing sum of first
// and last terms
// in above formula
$s = y($a) + y($b);
// Adding middle terms
// in above formula
for ($i = 1; $i < $n; $i++)
$s += 2 * Y($a + $i * $h);
// h/2 indicates (b-a)/2n.
// Multiplying h/2 with s.
return ($h / 2) * $s;
}
// Driver Code
// Range of definite integral
$x0 = 0;
$xn = 1;
// Number of grids.
// Higher value means
// more accuracy
$n = 6;
echo("Value of integral is ");
echo(trapezoidal($x0, $xn, $n));
// This code is contributed by nitin mittal
?>
Javascript
<script>
// Javascript program to implement Trapezoidal rule
// A sample function whose definite
// integral's approximate value
// is computed using Trapezoidal
// rule
function y(x)
{
// Declaring the function
// f(x) = 1/(1+x*x)
return 1 / (1 + x * x);
}
// Function to evaluate the value of integral
function trapezoidal(a, b, n)
{
// Grid spacing
let h = (b - a) / n;
// Computing sum of first and last terms
// in above formula
let s = y(a) + y(b);
// Adding middle terms in above formula
for(let i = 1; i < n; i++)
s += 2 * y(a + i * h);
// h/2 indicates (b-a)/2n. Multiplying h/2
// with s.
return (h / 2) * s;
}
// Driver code
// Range of definite integral
let x0 = 0;
let xn = 1;
// Number of grids. Higher
// value means more accuracy
let n = 6;
document.write("Value of integral is "+
Math.round(trapezoidal(x0, xn, n) *
10000.0) / 10000.0);
// This code is contributed by code_hunt
</script>
Producción:
Value of integral is 0.7842
Referencias:
https://en.wikipedia.org/wiki/Trapezoidal_rule
Este artículo es una contribución de Harsh Agarwal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA