+midpoint and right rectangle rule functions

fusion809 · fusion809 · commit 86eef8158cb6 · 2020-06-30T17:38:09.000+10:00
diff --git a/Project.toml b/Project.toml
@@ -1,7 +1,7 @@
 name = "FunctionIntegrator"
 uuid = "7685536e-2581-4f83-bef1-2ba363c9cb91"
 authors = ["Brenton Horne <brentonhorne77@gmail.com>"]
-version = "0.2.1"
+version = "0.3.0"
 
 [deps]
 FastGaussQuadrature = "442a2c76-b920-505d-bb47-c5924d526838"
diff --git a/src/FunctionIntegrator.jl b/src/FunctionIntegrator.jl
@@ -2,7 +2,7 @@ module FunctionIntegrator
 
 using FastGaussQuadrature
 
-export chebyshev_quadrature, hermite_quadrature, jacobi_quadrature, laguerre_quadrature, legendre_quadrature, lobatto_quadrature, radau_quadrature, rectangle_rule, simpsons_rule, trapezoidal_rule
+export chebyshev_quadrature, hermite_quadrature, jacobi_quadrature, laguerre_quadrature, legendre_quadrature, lobatto_quadrature, radau_quadrature, rectangle_rule_left, rectangle_rule_midpoint, rectangle_rule_right, simpsons_rule, trapezoidal_rule
 
 include("Chebyshev.jl")
 include("Hermite.jl")
diff --git a/src/Rectangle.jl b/src/Rectangle.jl
@@ -1,13 +1,13 @@
 """
-    rectangle_rule(f::Function, N::Number, a::Number, b::Number)
+    rectangle_rule_left(f::Function, N::Number, a::Number, b::Number)
 
 numerically approximates:
 
 ``\\displaystyle\\int_a^b f(x) dx``
 
-using the [rectangle rule](https://en.wikipedia.org/wiki/Riemann_sum#Left_Riemann_sum) with ``N`` gridpoint values. Whilst the type mentioned in the function definition for ``N`` is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'); an error message will be printed if it is not a positive integer. 
+using the [left rectangle rule](https://en.wikipedia.org/wiki/Riemann_sum#Left_Riemann_sum) with ``N`` gridpoint values. Whilst the type mentioned in the function definition for ``N`` is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'); an error message will be printed if it is not a positive integer.
 """
-function rectangle_rule(f::Function, N::Number, a::Number, b::Number)
+function rectangle_rule_left(f::Function, N::Number, a::Number, b::Number)
     N = convert(Int64, N);
     h = (b-a)/N;
     y = 0;
@@ -18,3 +18,45 @@ function rectangle_rule(f::Function, N::Number, a::Number, b::Number)
     end
     return y
 end
+
+"""
+    rectangle_rule_midpoint(f::Function, N::Number, a::Number, b::Number)
+
+numerically approximates:
+
+``\\displaystyle\\int_a^b f(x) dx``
+
+using the [midpoint rectangle rule](https://en.wikipedia.org/wiki/Riemann_sum#Midpoint_rule) with ``N`` gridpoint values. Whilst the type mentioned in the function definition for ``N`` is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'); an error message will be printed if it is not a positive integer.
+"""
+function rectangle_rule_midpoint(f::Function, N::Number, a::Number, b::Number)
+    N = convert(Int64, N);
+    h = (b-a)/N;
+    y = 0;
+    x = a+h/2;
+    for i=1:N
+        y += h*f(x)
+        x = x + h;
+    end
+    return y
+end
+
+"""
+    rectangle_rule_right(f::Function, N::Number, a::Number, b::Number)
+
+numerically approximates:
+
+``\\displaystyle\\int_a^b f(x) dx``
+
+using the [right rectangle rule](https://en.wikipedia.org/wiki/Riemann_sum#Right_Riemann_sum) with ``N`` gridpoint values. Whilst the type mentioned in the function definition for ``N`` is just 'Number' (as opposed to 'Integer'), this is just so that scientific notation can be used to define it (as scientific notation gives the type 'Float64'); an error message will be printed if it is not a positive integer.
+"""
+function rectangle_rule_right(f::Function, N::Number, a::Number, b::Number)
+    N = convert(Int64, N);
+    h = (b-a)/N;
+    y = 0;
+    x = a+h;
+    for i=1:N
+        y += h*f(x)
+        x = x + h;
+    end
+    return y
+end
diff --git a/test/airyai.jl b/test/airyai.jl
@@ -19,8 +19,12 @@ printstyled("Performing the Airy Ai(x) test, where Ai(x) is integrated on the se
     @time @test lobatto_quadrature(x -> airyai(x), 37, 0, 100) ≈ 1.0/3.0
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(x -> airyai(x), 37, 0, 100) ≈ 1.0/3.0
-    printstyled("Running: rectangle_rule. Only a rough approximation can be practically achieved using this function.\n"; color = :magenta)
-    @time @test abs(rectangle_rule(x -> airyai(x), 1e8, 0, 100) - 1.0/3.0) < 1e-6
+    printstyled("Running: rectangle_rule_left. Only a rough approximation can be practically achieved using this function.\n"; color = :magenta)
+    @time @test abs(rectangle_rule_left(x -> airyai(x), 1e8, 0, 100) - 1.0/3.0) < 1.775106856505283e-7
+    printstyled("Running: rectangle_rule_midpoint.\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(x -> airyai(x), 147348, 0, 100) ≈ 1.0/3.0
+    printstyled("Running: rectangle_rule_right. Only a rough approximation can be practically achieved using this function.\n"; color = :magenta)
+    @time @test abs(rectangle_rule_right(x -> airyai(x), 1e8, 0, 100) - 1.0/3.0) < 1.775176824944687e-7
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(x -> airyai(x), 2511, 0, 100) ≈ 1.0/3.0
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
diff --git a/test/besselj.jl b/test/besselj.jl
@@ -21,8 +21,12 @@ printstyled("Performing the besselj test, where BesselJ_1(2) is approximated and
     @time @test lobatto_quadrature(besselj_integrand, 9, 0, pi/2) ≈ besselj(1,2)
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(besselj_integrand, 8, 0, pi/2) ≈ besselj(1,2)
-    printstyled("Running: rectangle_rule\n"; color = :magenta)
-    @time @test rectangle_rule(besselj_integrand, 52378763, 0, pi/2) ≈ besselj(1,2)
+    printstyled("Running: rectangle_rule_left\n"; color = :magenta)
+    @time @test rectangle_rule_left(besselj_integrand, 52378763, 0, pi/2) ≈ besselj(1,2)
+    printstyled("Running: rectangle_rule_midpoint\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(besselj_integrand, 4, 0, pi/2) ≈ besselj(1,2)
+    printstyled("Running: rectangle_rule_right\n"; color = :magenta)
+    @time @test rectangle_rule_right(besselj_integrand, 52995612, 0, pi/2) ≈ besselj(1,2)
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(besselj_integrand, 6, 0, pi/2) ≈ besselj(1,2)
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
diff --git a/test/cos_cot_integral.jl b/test/cos_cot_integral.jl
@@ -23,8 +23,12 @@ printstyled("Integrating cos^2(x)/(1+cot(x)) from 0 to pi/2 and comparing the re
     @time @test lobatto_quadrature(cos_cot_fn, 7, 0, pi/2) ≈ 0.25
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(cos_cot_fn, 8, 0, pi/2) ≈ 0.25
-    printstyled("Running: rectangle_rule\n"; color = :magenta)
-    @time @test rectangle_rule(cos_cot_fn, 7430, 0, pi/2) ≈ 0.25
+    printstyled("Running: rectangle_rule_left\n"; color = :magenta)
+    @time @test rectangle_rule_left(cos_cot_fn, 7430, 0, pi/2) ≈ 0.25
+    printstyled("Running: rectangle_rule_midpoint\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(cos_cot_fn, 5254, 0, pi/2) ≈ 0.25
+    printstyled("Running: rectangle_rule_right\n"; color = :magenta)
+    @time @test rectangle_rule_right(cos_cot_fn, 7430, 0, pi/2) ≈ 0.25
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(cos_cot_fn, 78, 0, pi/2) ≈ 0.25
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
diff --git a/test/cosine.jl b/test/cosine.jl
@@ -17,8 +17,12 @@ printstyled("Integrating cosine from 0 to pi/2 and comparing the result to the a
     @time @test lobatto_quadrature(x -> cos.(x), 6, 0, pi/2) ≈ 1
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(x -> cos.(x), 5, 0, pi/2) ≈ 1
-    printstyled("Running: rectangle_rule\n"; color = :magenta)
-    @time @test rectangle_rule(x -> cos.(x), 5.23705e7, 0, pi/2) ≈ 1
+    printstyled("Running: rectangle_rule_left\n"; color = :magenta)
+    @time @test rectangle_rule_left(x -> cos.(x), 5.23705e7, 0, pi/2) ≈ 1
+    printstyled("Running: rectangle_rule_midpoint\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(x -> cos.(x), 2627, 0, pi/2) ≈ 1
+    printstyled("Running: rectangle_rule_right\n"; color = :magenta)
+    @time @test rectangle_rule_right(x -> cos.(x), 5.2441522e7, 0, pi/2) ≈ 1
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(x -> cos.(x), 40, 0, pi/2) ≈ 1
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
diff --git a/test/expnx2datan.jl b/test/expnx2datan.jl
@@ -23,8 +23,12 @@ printstyled("Integrating e^(-x^2)/(1+x^2) on the infinite domain [-inf, inf], or
     @time @test lobatto_quadrature(x -> exp.(-x.^2).*(x.^2+1).^(-1), 1029, -100, 100) ≈ sol_9
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(x -> exp.(-x.^2).*(x.^2+1).^(-1), 669, -100, 100) ≈ sol_9
-    printstyled("Running: rectangle_rule\n"; color = :magenta)
-    @time @test rectangle_rule(x -> exp.(-x.^2).*(x.^2+1).^(-1), 655, -100, 100) ≈ sol_9
+    printstyled("Running: rectangle_rule_left\n"; color = :magenta)
+    @time @test rectangle_rule_left(x -> exp.(-x.^2).*(x.^2+1).^(-1), 655, -100, 100) ≈ sol_9
+    printstyled("Running: rectangle_rule_midpoint\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(x -> exp.(-x.^2).*(x.^2+1).^(-1), 655, -100, 100) ≈ sol_9
+    printstyled("Running: rectangle_rule_right\n"; color = :magenta)
+    @time @test rectangle_rule_right(x -> exp.(-x.^2).*(x.^2+1).^(-1), 655, -100, 100) ≈ sol_9
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(x -> exp.(-x.^2).*(x.^2+1).^(-1), 1233, -100, 100) ≈ sol_9
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
diff --git a/test/gaussian.jl b/test/gaussian.jl
@@ -23,8 +23,12 @@ printstyled("Integrate exp(-x^2) from minus infinity to positive infinity and co
     @time @test lobatto_quadrature(x -> exp.(-x.^2), 434, -100, 100) ≈ sqrt(pi)
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(x -> exp.(-x.^2), 349, -100, 100) ≈ sqrt(pi)
-    printstyled("Running: rectangle_rule\n"; color = :magenta)
-    @time @test rectangle_rule(x -> exp.(-x.^2), 276, -100, 100) ≈ sqrt(pi)
+    printstyled("Running: rectangle_rule_left\n"; color = :magenta)
+    @time @test rectangle_rule_left(x -> exp.(-x.^2), 276, -100, 100) ≈ sqrt(pi)
+    printstyled("Running: rectangle_rule_midpoint\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(x -> exp.(-x.^2), 276, -100, 100) ≈ sqrt(pi)
+    printstyled("Running: rectangle_rule_right\n"; color = :magenta)
+    @time @test rectangle_rule_right(x -> exp.(-x.^2), 276, -100, 100) ≈ sqrt(pi)
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(x -> exp.(-x.^2), 533, -100, 100) ≈ sqrt(pi)
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
diff --git a/test/logarithm.jl b/test/logarithm.jl
@@ -17,8 +17,12 @@ printstyled("Integrating 1/x from 1 to e and comparing the result to the analyti
     @time @test lobatto_quadrature(x -> x.^(-1), 8, 1, exp(1)) ≈ 1
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(x -> x.^(-1), 8, 1, exp(1)) ≈ 1
-    printstyled("Running: rectangle_rule\n"; color = :magenta)
-    @time @test rectangle_rule(x -> x.^(-1), 7.74699e7, 1, exp(1)) ≈ 1
+    printstyled("Running: rectangle_rule_left\n"; color = :magenta)
+    @time @test rectangle_rule_left(x -> x.^(-1), 7.74699e7, 1, exp(1)) ≈ 1
+    printstyled("Running: rectangle_rule_midpoint\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(x -> x.^(-1), 2672, 1, exp(1)) ≈ 1
+    printstyled("Running: rectangle_rule_right\n"; color = :magenta)
+    @time @test rectangle_rule_right(x -> x.^(-1), 3.6607201e7, 1, exp(1)) ≈ 1
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(x -> x.^(-1), 70, 1, exp(1)) ≈ 1
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
diff --git a/test/logoverx.jl b/test/logoverx.jl
@@ -16,8 +16,12 @@ printstyled("Integrating log(x)/x from 1 to e and comparing the result to the an
     @time @test lobatto_quadrature(x -> log.(x).*x.^(-1), 9, 1, exp(1)) ≈ 0.5
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(x -> log.(x).*x.^(-1), 8, 1, exp(1)) ≈ 0.5
-    printstyled("Running: rectangle_rule\n"; color = :magenta)
-    @time @test rectangle_rule(x -> log.(x).*x.^(-1), 4.3800001e7, 1, exp(1)) ≈ 0.5
+    printstyled("Running: rectangle_rule_left\n"; color = :magenta)
+    @time @test rectangle_rule_left(x -> log.(x).*x.^(-1), 4.3800001e7, 1, exp(1)) ≈ 0.5
+    printstyled("Running: rectangle_rule_midpoint\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(x -> log.(x).*x.^(-1), 4064, 1, exp(1)) ≈ 0.5
+    printstyled("Running: rectangle_rule_right\n"; color = :magenta)
+    @time @test rectangle_rule_right(x -> log.(x).*x.^(-1), 4.372011e7, 1, exp(1)) ≈ 0.5
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(x -> log.(x).*x.^(-1), 100, 1, exp(1)) ≈ 0.5
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
diff --git a/test/modbessel0.jl b/test/modbessel0.jl
@@ -25,8 +25,12 @@ printstyled("Approximating the modified bessel function I_1(1) and comparing it
     @time @test lobatto_quadrature(dmodified_bessel_1, 8, 0, pi/2) ≈ besseli(x,1)
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(dmodified_bessel_1, 8, 0, pi/2) ≈ besseli(x,1)
-    printstyled("Running: rectangle_rule\n"; color = :magenta)
-    @time @test rectangle_rule(dmodified_bessel_1, 58999999, 0, pi/2) ≈ besseli(x,1)
+    printstyled("Running: rectangle_rule_left\n"; color = :magenta)
+    @time @test rectangle_rule_left(dmodified_bessel_1, 58999999, 0, pi/2) ≈ besseli(x,1)
+    printstyled("Running: rectangle_rule_midpoint\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(dmodified_bessel_1, 3, 0, pi/2) ≈ besseli(x,1)
+    printstyled("Running: rectangle_rule_right\n"; color = :magenta)
+    @time @test rectangle_rule_right(dmodified_bessel_1, 59275151, 0, pi/2) ≈ besseli(x,1)
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(dmodified_bessel_1, 6, 0, pi/2) ≈ besseli(x,1)
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
diff --git a/test/simppen.jl b/test/simppen.jl
@@ -19,8 +19,12 @@ printstyled("Integrating 1/sqrt(-19.6 sin(x)) from -pi to 0 and comparing the re
     @time @test abs(lobatto_quadrature(x -> (-19.6*sin.(x)).^(-0.5), 1e6, -pi+1e-6, -1e-6) - ellipk(1/2)/sqrt(2.45)) < 1e-3
     printstyled("Running: radau_quadrature on [-pi+1e-6, -1e-6]. Only a rough approximation can be realistically achieved with this function, partly due to the singularities.\n"; color = :magenta)
     @time @test abs(radau_quadrature(x -> (-19.6*sin.(x)).^(-0.5), 1e6, -pi+1e-6, -1e-6) - ellipk(1/2)/sqrt(2.45)) < 1e-3
-    printstyled("Running: rectangle_rule on [-pi+1e-8, -1e-8]. Only a rough approximation can be realistically achieved with this function, partly due to the singularities.\n"; color = :magenta)
-    @time @test abs(rectangle_rule(x -> (-19.6*sin.(x)).^(-0.5), 1e8, -pi+1e-8, -1e-8) - ellipk(1/2)/sqrt(2.45)) < 1e-4
+    printstyled("Running: rectangle_rule_left on [-pi+1e-8, -1e-8]. Only a rough approximation can be realistically achieved with this function, partly due to the singularities.\n"; color = :magenta)
+    @time @test abs(rectangle_rule_left(x -> (-19.6*sin.(x)).^(-0.5), 1e8, -pi+1e-8, -1e-8) - ellipk(1/2)/sqrt(2.45)) < 1e-4
+    printstyled("Running: rectangle_rule_midpoint on [-pi+1e-8, -1e-8]. Only a rough approximation can be realistically achieved with this function, partly due to the singularities.\n"; color = :magenta)
+    @time @test abs(rectangle_rule_midpoint(x -> (-19.6*sin.(x)).^(-0.5), 1e8, -pi+1e-8, -1e-8) - ellipk(1/2)/sqrt(2.45)) < 1.01e-4
+    printstyled("Running: rectangle_rule_right on [-pi+1e-8, -1e-8]. Only a rough approximation can be realistically achieved with this function, partly due to the singularities.\n"; color = :magenta)
+    @time @test abs(rectangle_rule_right(x -> (-19.6*sin.(x)).^(-0.5), 1e8, -pi+1e-8, -1e-8) - ellipk(1/2)/sqrt(2.45)) < 8.649e-5
     printstyled("Running: simpsons_rule on [-pi+1e-8, -1e-8]. Only a rough approximation can be realistically achieved with this function, partly due to the singularities.\n"; color = :magenta)
     @time @test abs(simpsons_rule(x -> (-19.6*sin.(x)).^(-0.5), 1e8, -pi+1e-8, -1e-8) - ellipk(1/2)/sqrt(2.45)) < 1e-4
     printstyled("Running: trapezoidal_rule on [-pi+1e-8, -1e-8]. Only a rough approximation can be realistically achieved with this function, partly due to the singularities.\n"; color = :magenta)
diff --git a/test/sinexpox.jl b/test/sinexpox.jl
@@ -29,8 +29,12 @@ printstyled("Integrating sin(x^2)e^(-x)/x from 0 to infinity, with the approxima
     @time @test lobatto_quadrature(sinexpox, 598, 0, 100) ≈ sol_11
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(sinexpox, 498, 0, 100) ≈ sol_11
-    printstyled("Running: rectangle_rule\n"; color = :magenta)
-    @time @test rectangle_rule(sinexpox, 394538, 0, 100) ≈ sol_11
+    printstyled("Running: rectangle_rule_left\n"; color = :magenta)
+    @time @test rectangle_rule_left(sinexpox, 394538, 0, 100) ≈ sol_11
+    printstyled("Running: rectangle_rule_midpoint\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(sinexpox, 278981, 0, 100) ≈ sol_11
+    printstyled("Running: rectangle_rule_right\n"; color = :magenta)
+    @time @test rectangle_rule_right(sinexpox, 394538, 0, 100) ≈ sol_11
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(sinexpox, 4201, 0, 100) ≈ sol_11
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
diff --git a/test/sinxx.jl b/test/sinxx.jl
@@ -23,8 +23,12 @@ printstyled("Integrating sin(x)/x from 0 to 100 and comparing it to the exact re
     @time @test lobatto_quadrature(sinxx, 38, 0, 100) ≈ sol_8
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(sinxx, 38, 0, 100) ≈ sol_8
-    printstyled("Running: rectangle_rule\n"; color = :magenta)
-    @time @test abs(rectangle_rule(sinxx, 1e8, 0, 100) - sol_8) < 1e-6
+    printstyled("Running: rectangle_rule_left; only a rough approximation can be practically achieved using this function\n"; color = :magenta)
+    @time @test abs(rectangle_rule_left(sinxx, 1e8, 0, 100) - sol_8) < 5.036e-7
+    printstyled("Running: rectangle_rule_midpoint\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(sinxx, 12461, 0, 100) ≈ sol_8
+    printstyled("Running: rectangle_rule_right; only a rough approximation can be practically achieved using this function\n"; color = :magenta)
+    @time @test abs(rectangle_rule_right(sinxx, 1e8, 0, 100) - sol_8) < 5.015e-7
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(sinxx, 678, 0, 100) ≈ sol_8
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
diff --git a/test/test_7.jl b/test/test_7.jl
@@ -22,8 +22,12 @@ printstyled("Integrating (x^3+1)/(x^4 (x+1)(x^2+1)) from 1 to e and comparing th
     @time @test lobatto_quadrature(partfrac, 11, 1, exp(1)) ≈ sol_7
     printstyled("Running: radau_quadrature\n"; color = :magenta)
     @time @test radau_quadrature(partfrac, 10, 1, exp(1)) ≈ sol_7
-    printstyled("Running: rectangle_rule; only a rough approximation can be practically achieved using this function.\n"; color = :magenta)
-    @time @test abs(rectangle_rule(partfrac, 1e8, 1, exp(1)) - sol_7) < 1e-8
+    printstyled("Running: rectangle_rule_left; only a rough approximation can be practically achieved using this function.\n"; color = :magenta)
+    @time @test abs(rectangle_rule_left(partfrac, 1e8, 1, exp(1)) - sol_7) < 1e-8
+    printstyled("Running: rectangle_rule_midpoint\n"; color = :magenta)
+    @time @test rectangle_rule_midpoint(partfrac, 9887, 1, exp(1)) ≈ sol_7
+    printstyled("Running: rectangle_rule_right; only a rough approximation can be practically achieved using this function.\n"; color = :magenta)
+    @time @test abs(rectangle_rule_right(partfrac, 1e8, 1, exp(1)) - sol_7) < 1e-8
     printstyled("Running: simpsons_rule\n"; color = :magenta)
     @time @test simpsons_rule(partfrac, 200, 1, exp(1)) ≈ sol_7
     printstyled("Running: trapezoidal_rule\n"; color = :magenta)
