First, let's address the error in your code—there are two key issues here:

• You defined your function as f but tried to integrate integrand (which isn't defined anywhere).
• Even if you used f, you didn't pass the required parameter a to the function when calling integrate().

Here's the corrected code to get a numerical integral result:

# Define your linear function
f <- function(x, a) {a * x}

# Set a value for parameter a (e.g., a = 3) and compute the integral from 0 to 2
result <- integrate(f, lower = 0, upper = 2, a = 3)
print(result)

This will return the numerical result 6 (since $\int_0^2 3x dx = 3*(2^2/2) = 6$), which matches the expected value.

Base R's integrate() function only handles numerical integration—it gives you a value over a specific range, not a symbolic formula like $\frac{a}{2}x^2 + C$. To get symbolic results, you'll need to use a package that supports symbolic mathematics. Two popular options are Ryacas and rSymPy:

Using Ryacas #

# Install and load the package
install.packages("Ryacas")
library(Ryacas)

# Define symbolic variables x and a
x <- ysym("x")
a <- ysym("a")

# Define your function symbolically
f <- a * x

# Compute the indefinite integral with respect to x
indefinite_integral <- Integrate(f, x)

# Print the result
cat("Indefinite integral:", as.character(indefinite_integral), "+ C\n")

This will output exactly what you're looking for: Indefinite integral: (a*x^2)/2 + C.

Using rSymPy #

# Install and load the package
install.packages("rSymPy")
library(rSymPy)

# Initialize SymPy
sympy <- initSymPy()

# Define symbolic variables
x <- Var("x")
a <- Var("a")

# Compute the indefinite integral
integral <- integrate(a*x, x)
print(integral)

This will also return the symbolic formula $\frac{a x^{2}}{2}$.

For integrals in 2D or higher dimensions, base R doesn't have a built-in function, but several packages can handle this efficiently. Here are three common approaches:

Using the cubature Package (Adaptive Integration) #

Great for general-purpose multidimensional integration with adaptive sampling:

install.packages("cubature")
library(cubature)

# Define a 2D function (e.g., f(x,y) = a*x*y)
f_2d <- function(vec, a) {
  x <- vec[1]
  y <- vec[2]
  a * x * y
}

# Compute the integral over x ∈ [0,2] and y ∈ [0,3] with a=3
result_2d <- adaptIntegrate(f_2d, lowerLimit = c(0,0), upperLimit = c(2,3), a=3)
print(result_2d)

This returns the exact result 27 (since $\int_0^2 \int_0^3 3xy dy dx = 3*(2^2/2)*(32/2) = 27$).

Using the mvQuad Package (Quadrature-Based Integration) #

Ideal if you need to use custom quadrature grids:

install.packages("mvQuad")
library(mvQuad)

# Create a 2D Gauss-Legendre quadrature grid
grid <- createNIGrid(dim=2, type="GLe", level=10)

# Define the 2D function
f_2d <- function(x) {3 * x[1] * x[2]}

# Set the integration limits
setDomain(grid, lower=c(0,0), upper=c(2,3))

# Compute the integral
result_mvQuad <- quadrature(f_2d, grid)
print(result_mvQuad)

Using the pracma Package #

Offers an adaptIntegrate function similar to cubature, plus other useful math utilities:

install.packages("pracma")
library(pracma)

# Compute the 2D integral
result_pracma <- adaptIntegrate(f_2d, c(0,0), c(2,3), a=3)
print(result_pracma)

内容的提问来源于stack exchange，提问作者gariban