Power Series and Functional Representation: How Calculus Represents Complex Systems

Last Updated June 29, 2026

Power series represent functions through infinite polynomial expansions, turning local functional behavior into structured approximation, analysis, and computation. A power series expresses a function as a sum of powers centered around a point. Instead of treating a function only as a black-box rule, power series reveal how constant terms, linear terms, curvature, higher-order effects, convergence radius, and truncation error shape what the function means locally and how far that representation can be trusted.

In systems modeling, power series matter because many models rely on approximation. Nonlinear relationships may be represented locally by polynomial terms. Complex functions may be expanded into simpler pieces. Numerical methods may use finite truncations of infinite expansions. Sensitivity analysis may depend on first-order or higher-order approximations. Stability analysis may ask how a system behaves near equilibrium. A power series provides a disciplined bridge between exact functional form and usable computational representation.

This article develops power series as tools for functional representation. It examines series structure, centers of expansion, radius and interval of convergence, coefficient interpretation, analytic functions, polynomial approximation, generated functions, local model behavior, truncation, error, and responsible use in systems modeling.

Power series are not merely a symbolic technique. They are a way to represent function behavior through increasingly refined local structure. The first term may describe a baseline. The next term may describe local slope. Higher-order terms may describe curvature, acceleration, asymmetry, saturation, oscillation, or nonlinear response. The series becomes a modeling language for how a function behaves near a chosen center and how that behavior may or may not extend beyond that local region.

The strength of this language is also its danger. A power series can turn a difficult function into a sequence of manageable polynomial terms, but every such representation carries a center, a coefficient rule, a convergence region, and an omitted remainder. In systems modeling, those details are not decorative. They determine whether the approximation is a trustworthy local representation, a useful computational device, or a polished-looking extrapolation beyond the mathematical support of the model.

Why Power Series Matter

Power series matter because many functions are easier to understand, approximate, compute, or compare when represented as polynomial structures. A complicated nonlinear function may be difficult to interpret directly. A power series breaks it into terms whose roles can be examined: constant level, slope, curvature, higher-order change, and residual structure.

A power series centered at \(a\) has the form:

In modeling, this structure is valuable because it supports approximation. A finite truncation gives a polynomial model:

The practical question is not only whether such a polynomial can be computed. The question is whether it represents the function well enough for the modeling purpose and over what interval. This connects power series directly to convergence, approximation error, local validity, and responsible interpretation.

Power series therefore sit at the intersection of function theory, approximation, numerical computation, and modeling judgment.

Back to top ↑

What Is a Power Series?

A power series is an infinite series whose terms are powers of a variable, usually measured relative to a center point. The simplest center is zero:

More generally, the series may be centered at \(a\):

The coefficients \(c_n\) determine how much each power contributes. The constant term sets the baseline. The linear term shapes the local slope. The quadratic term contributes curvature. Higher-order terms refine nonlinear structure. As more terms are added, the partial sums may approximate the target function more accurately within the region where the series converges.

The finite partial sum is:

Power series are therefore both infinite objects and finite computational tools. The infinite series defines the representation when it converges. The finite polynomial gives a practical approximation when a modeler stops after a chosen number of terms.

Back to top ↑

Centers and Local Representation

The center of a power series matters. A series centered at \(a\) represents behavior in relation to \(a\). Near that center, the first few terms often capture important local behavior. Far from the center, the representation may require many terms, converge slowly, or fail entirely.

The displacement from the center is \(x-a\). When \(|x-a|\) is small, higher powers often shrink rapidly:

This is why power series are local tools. A first-order approximation may work near the center because the linear term dominates. A second-order approximation may add curvature. Higher-order approximations may capture more subtle behavior. But as \(x\) moves away from \(a\), the relative importance of omitted terms can grow.

Choosing a center is therefore a modeling decision, not merely a mathematical convenience. The center defines the local region from which the representation draws its meaning.

Back to top ↑

Coefficients and Functional Meaning

The coefficients of a power series determine the shape of the representation. In a general power series, the coefficients \(c_n\) may be chosen, estimated, derived from a known function, or computed through derivatives. In a Taylor series, the coefficients are tied directly to derivatives at the center:

This gives each term an interpretive role. The coefficient \(c_0\) is the function value at the center. The coefficient \(c_1\) reflects local slope. The coefficient \(c_2\) is tied to curvature. Higher coefficients encode increasingly subtle local structure.

Coefficient interpretation is powerful, but it can also mislead if the representation is treated globally. A local coefficient describes behavior near the center. It does not automatically describe the entire system across all possible values.

Back to top ↑

Taylor, Maclaurin, and Local Derivative Data

A Taylor series is a power series whose coefficients come from derivatives of a function at a chosen center. A Maclaurin series is the special case centered at zero. The difference is not only notation. The center determines which local behavior is being encoded and which part of the system is treated as the reference condition.

When the center is zero, the same structure becomes a Maclaurin series:

This derivative structure explains why Taylor expansions are central to local modeling. A first-order expansion preserves the function value and slope at the center. A second-order expansion preserves curvature. Higher-order terms preserve increasingly refined local behavior. The result is not merely an approximation formula; it is a compact record of how a system responds to small movement away from a reference state.

Derivative data can be extraordinarily revealing, but it remains local. A Taylor polynomial centered at a normal operating condition may work well for modest perturbations and fail under shocks, thresholds, discontinuities, saturation, or regime change. The mathematical issue is convergence and error. The modeling issue is whether the local reference point still represents the system being interpreted.

Back to top ↑

Radius and Interval of Convergence

A power series may not converge for every value of \(x\). For most power series, there is a radius of convergence \(R\) around the center \(a\). Inside that radius, the series converges. Outside that radius, it diverges. At the boundary, each endpoint must be checked separately.

The interval of convergence includes all \(x\)-values where the series converges. It may be written as an interval around the center, with endpoint behavior determined by separate tests.

For systems modeling, the radius of convergence is a domain-of-validity warning. A finite polynomial may produce numbers outside the convergence interval, but those numbers are not justified by the power-series representation. Computation can continue after convergence has failed. Interpretation should not.

Back to top ↑

The Geometric Series as the Basic Model

The geometric series is the foundational power series. Centered at zero, it has the form:

It converges when \(|x|<1\), and its sum is:

This example matters because it demonstrates several central ideas at once. A power series may equal a familiar function, but only on a specific interval. The finite partial sums approximate the function increasingly well inside that interval. Outside the interval, the same algebraic-looking series diverges even though the function \(1/(1-x)\) may still be defined for many values.

In systems modeling, the geometric series appears in discounting, feedback multipliers, impulse response, repeated proportional effects, recursive correction, and decaying tail contributions. It is also a reminder that representation depends on domain. The formula may be true inside the convergence interval and false as a series representation outside it.

Back to top ↑

Analytic Functions and Representation

A function is analytic near a point if it can be represented by a convergent power series in some neighborhood of that point. This is stronger than being differentiable many times. An analytic function is not merely smooth; its local derivative information determines a convergent series representation of the function.

A Taylor series centered at \(a\) has the form:

The phrase “converges to \(f(x)\)” is important. A Taylor series may exist formally, and it may converge, but it must also converge to the function being represented. Smoothness alone does not guarantee that a function is equal to its Taylor series around a point.

For systems modeling, this distinction matters because local smoothness can encourage overconfidence. A modeler may fit a polynomial or use derivative-based approximation and assume it represents the underlying function beyond the local region. Analytic representation requires more: convergence, equality to the function, and domain awareness.

Analytic representation is therefore a claim about the relationship between a function and a convergent series, not just about the existence of derivatives.

Back to top ↑

Operations on Power Series

Power series can often be manipulated like polynomials inside their intervals of convergence. They can be added, multiplied, differentiated, integrated, shifted, and transformed. These operations make them useful in modeling and computation.

If a power series converges inside its radius, it can often be differentiated term by term:

It can also be integrated term by term:

These operations preserve the same radius of convergence for differentiation and integration, though endpoint behavior may change and must be reviewed separately.

For systems modeling, this means a power-series representation can support linked analysis of levels, rates, and accumulated quantities. A series representation of a response function may produce a series for marginal response. A series for a rate may be integrated into a series for accumulated burden. A series for a potential may be differentiated into a force or gradient. The representation becomes a computational framework, not merely a formula.

Back to top ↑

Local Approximation and Truncation

In practice, modelers rarely use an infinite series directly. They use a finite truncation. The \(N\)-th partial sum is a polynomial:

The missing part is the remainder:

Truncation is useful because it makes infinite representation computationally manageable. It is risky because the omitted terms may matter. Near the center, omitted higher-order terms may be small. Farther away, they may dominate. In some cases, a few terms provide excellent approximation. In others, many terms are required or the series fails to converge.

A finite polynomial is not automatically a trustworthy model. It is a controlled approximation only when convergence, domain, and error are addressed.

Back to top ↑

Remainder Terms and Error Control

A finite Taylor or power-series approximation is useful only because the omitted part is understood, bounded, or judged acceptable for the model’s purpose. The remainder is the difference between the target function and the polynomial that has been retained:

For a Taylor approximation, one common form of the Lagrange remainder is:

This formula gives a useful modeling lesson even when the exact \(\xi\) is unknown: approximation error usually grows with distance from the center and shrinks when higher-order terms are controlled. A low-order polynomial may be excellent near the expansion center and unreliable farther away. The same finite expression can therefore be both a rigorous local approximation and a poor global model.

Different series call for different error logic. A geometric tail has a closed-form remainder. An alternating series may have an error bounded by the first omitted term when the hypotheses are satisfied. A Taylor approximation may use derivative bounds. A numerical workflow may compare successive orders and evaluation points, but stabilization alone should not be treated as proof.

The central question is not whether a polynomial can be written down. It is whether the omitted terms are small enough, bounded enough, or irrelevant enough for the claim being made.

Back to top ↑

Systems Modeling Interpretation

Power series provide a language for representing system behavior near a reference condition. This is especially useful when systems are nonlinear but locally manageable. Around an equilibrium, baseline, mean state, operating point, or design point, a power series can reveal how the system responds to small changes.

For example, a response function \(f(x)\) near \(a\) may be approximated by:

This structure supports modeling interpretation. The linear term indicates marginal response. The quadratic term indicates whether response accelerates, decelerates, or bends. Higher-order terms may reveal more complex local behavior. In dynamic systems, similar expansions can help analyze stability near equilibrium. In economics, they can approximate utility, cost, production, or risk functions. In ecology, they can approximate growth, saturation, or response curves. In physics and engineering, they can approximate forces, fields, and nonlinear relationships.

But local representation must not be overextended. A polynomial approximation near one state may fail after a shock, threshold, regime change, discontinuity, or domain boundary. The modeler must ask: Where is the center? What is the radius or interval of convergence? How many terms were kept? What error is acceptable? What system behavior is being ignored by truncation?

Back to top ↑

Power Series, Differential Equations, and Generating Functions

Power series also provide a way to build functions from structural rules. In differential equations, an unknown solution can sometimes be written as a series:

Substituting this form into a differential equation can produce recurrence relations for the coefficients. The differential equation then becomes a rule for generating the series term by term. This approach is especially useful near ordinary points, equilibrium states, or boundary conditions where the local behavior of the solution is more accessible than a closed-form expression.

Power-series thinking also appears in generating functions, where a sequence is encoded as a formal series:

Generating functions connect naturally to systems models with discrete states, counts, queues, recursions, branching processes, and combinatorial structure. The coefficient \(a_n\) may represent a count, probability, population state, transition total, or number of pathways. The function \(G(x)\) packages the sequence into an object that can be manipulated algebraically.

These uses broaden the meaning of power series. They are not only approximations to known functions. They can also be constructive tools for defining, solving, encoding, and auditing system behavior.

Back to top ↑

Scaling, Conditioning, and Numerical Stability

Computing with power series requires numerical discipline. A series that is mathematically valid may still be difficult to evaluate accurately if terms are large, cancellation is severe, or \(x\) is far from the center. The choice of center, scaling, ordering, and evaluation method can affect stability.

One common improvement is to work with a scaled displacement:

Polynomial evaluation also matters. A polynomial written as separate powers may be less stable and less efficient than Horner’s form:

Numerical stability is not separate from interpretation. If a power-series approximation is being used to support a forecast, sensitivity study, or policy calculation, the workflow should show not only the formula but also how it was evaluated, where it was evaluated, how error was estimated, and whether results remain stable under changes in order, scale, and center.

A power-series calculation is therefore not complete when a polynomial appears on the page. It becomes auditable when center, scaling, order, convergence, error, and evaluation method are all visible.

Back to top ↑

Mathematical Deepening

Power series reward careful boundary work. The same expression can be an exact representation inside one domain, a useful approximation near a center, and a misleading extrapolation outside its region of support. The mathematics keeps those roles separate by tracking convergence, coefficient structure, analytic equality, endpoint behavior, and remainder control.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational power-series workflows should record the target function, expansion center, coefficient rule, number of retained terms, convergence interval if known, evaluation points, finite approximation, reference value when available, error estimate, and warning. They should distinguish a symbolic representation from a numerical truncation and a local approximation from a global claim.

Good workflows compare approximations at multiple distances from the center. They report how error changes as more terms are added. They warn when evaluation occurs outside the convergence interval. They store outputs in CSV and JSON formats so approximation claims can be audited later.

The workflow should also distinguish coefficient provenance. Coefficients derived from a known Taylor expansion have a different status from coefficients fitted from data, inferred from a numerical model, or selected for a reduced-order approximation. Each case can be useful, but each carries different assumptions about error, extrapolation, and interpretability.

Back to top ↑

Python Workflow: Power-Series Approximation Audit

The Python workflow below approximates the geometric function \(1/(1-x)\) using finite power-series truncations and records convergence-aware diagnostics.

from __future__ import annotations

from dataclasses import dataclass, asdict
from pathlib import Path
import csv
import json


@dataclass(frozen=True)
class PowerSeriesAudit:
    function_name: str
    center: float
    x_value: float
    n_terms: int
    partial_sum: float
    reference_value: float | None
    absolute_error: float | None
    convergence_status: str
    warning: str


def geometric_power_series(x: float, n_terms: int) -> float:
    return sum(x ** n for n in range(n_terms))


def geometric_reference(x: float) -> float | None:
    if x == 1:
        return None
    return 1.0 / (1.0 - x)


def audit_geometric_series(x: float, n_terms: int) -> PowerSeriesAudit:
    partial = geometric_power_series(x, n_terms)
    converges = abs(x) < 1
    reference = geometric_reference(x) if converges else None
    error = abs(reference - partial) if reference is not None else None

    return PowerSeriesAudit(
        function_name="1/(1-x)",
        center=0.0,
        x_value=x,
        n_terms=n_terms,
        partial_sum=partial,
        reference_value=reference,
        absolute_error=error,
        convergence_status="inside radius of convergence" if converges else "outside radius of convergence",
        warning="" if converges else "Power series does not converge for this x value."
    )


records = [
    audit_geometric_series(x=0.25, n_terms=5),
    audit_geometric_series(x=0.25, n_terms=10),
    audit_geometric_series(x=0.75, n_terms=5),
    audit_geometric_series(x=0.75, n_terms=20),
    audit_geometric_series(x=1.25, n_terms=10)
]

output_dir = Path("outputs")
(output_dir / "tables").mkdir(parents=True, exist_ok=True)
(output_dir / "json").mkdir(parents=True, exist_ok=True)

with (output_dir / "tables" / "power_series_approximation_audit.csv").open("w", newline="", encoding="utf-8") as handle:
    writer = csv.DictWriter(handle, fieldnames=asdict(records[0]).keys())
    writer.writeheader()
    for record in records:
        writer.writerow(asdict(record))

(output_dir / "json" / "power_series_approximation_audit.json").write_text(
    json.dumps([asdict(record) for record in records], indent=2),
    encoding="utf-8"
)

print("Wrote power-series approximation audit.")

This workflow shows how approximation quality depends on the evaluation point, number of terms, and convergence interval.

Back to top ↑

R Workflow: Polynomial Approximation Diagnostics

The R workflow below compares finite partial sums of the geometric power series across multiple \(x\)-values and term counts.

# Power Series and Functional Representation
# Base R workflow for convergence-aware polynomial approximation.

geometric_power_series <- function(x, n_terms) {
  n <- 0:(n_terms - 1)
  sum(x^n)
}

geometric_reference <- function(x) {
  if (x == 1) {
    return(NA)
  }
  1 / (1 - x)
}

audit_geometric_series <- function(x, n_terms) {
  partial_sum <- geometric_power_series(x, n_terms)
  converges <- abs(x) < 1
  reference_value <- ifelse(converges, geometric_reference(x), NA)
  absolute_error <- ifelse(converges, abs(reference_value - partial_sum), NA)

  data.frame(
    function_name = "1/(1-x)",
    center = 0,
    x_value = x,
    n_terms = n_terms,
    partial_sum = partial_sum,
    reference_value = reference_value,
    absolute_error = absolute_error,
    convergence_status = ifelse(converges, "inside radius of convergence", "outside radius of convergence"),
    warning = ifelse(converges, "", "Power series does not converge for this x value.")
  )
}

cases <- rbind(
  audit_geometric_series(0.25, 5),
  audit_geometric_series(0.25, 10),
  audit_geometric_series(0.75, 5),
  audit_geometric_series(0.75, 20),
  audit_geometric_series(1.25, 10)
)

dir.create("outputs/tables", recursive = TRUE, showWarnings = FALSE)
write.csv(cases, "outputs/tables/r_power_series_approximation_audit.csv", row.names = FALSE)

print(cases)

This workflow keeps the reference value, partial sum, convergence status, and warning separate for each evaluated case.

Back to top ↑

Haskell Workflow: Typed Series Records

Haskell can represent power-series approximation records with explicit fields for center, evaluation point, convergence status, and warning.

module Main where

newtype Center = Center Double deriving (Show)
newtype XValue = XValue Double deriving (Show)
newtype TermCount = TermCount Int deriving (Show)
newtype PartialSum = PartialSum Double deriving (Show)
newtype AbsoluteError = AbsoluteError Double deriving (Show)

data ConvergenceStatus
  = InsideRadius
  | OutsideRadius
  deriving (Show)

data PowerSeriesAudit = PowerSeriesAudit
  { functionName :: String
  , center :: Center
  , xValue :: XValue
  , nTerms :: TermCount
  , partialSum :: PartialSum
  , referenceValue :: Maybe Double
  , absoluteError :: Maybe AbsoluteError
  , convergenceStatus :: ConvergenceStatus
  , warning :: String
  } deriving (Show)

geometricPowerSeries :: Double -> Int -> Double
geometricPowerSeries x nTerms =
  sum [x ** fromIntegral n | n <- [0..(nTerms - 1)]]

auditGeometric :: Double -> Int -> PowerSeriesAudit
auditGeometric x nTerms =
  let partial = geometricPowerSeries x nTerms
      converges = abs x < 1
      reference = if converges then Just (1.0 / (1.0 - x)) else Nothing
      err = fmap (\ref -> AbsoluteError (abs (ref - partial))) reference
  in PowerSeriesAudit
      { functionName = "1/(1-x)"
      , center = Center 0.0
      , xValue = XValue x
      , nTerms = TermCount nTerms
      , partialSum = PartialSum partial
      , referenceValue = reference
      , absoluteError = err
      , convergenceStatus = if converges then InsideRadius else OutsideRadius
      , warning = if converges then "" else "Power series does not converge for this x value."
      }

main :: IO ()
main = do
  print (auditGeometric 0.25 5)
  print (auditGeometric 0.25 10)
  print (auditGeometric 0.75 20)
  print (auditGeometric 1.25 10)

The typed structure prevents a finite partial sum from being confused with a valid convergent representation.

Back to top ↑

SQL Workflow: Power-Series Assumption Registry

SQL can document the assumptions behind a power-series approximation, especially when polynomial approximations support reporting, dashboards, governance, or future calculators.

CREATE TABLE power_series_assumption_registry (
    assumption_key TEXT PRIMARY KEY,
    assumption_name TEXT NOT NULL,
    mathematical_role TEXT NOT NULL,
    systems_modeling_role TEXT NOT NULL,
    review_warning TEXT NOT NULL
);

INSERT INTO power_series_assumption_registry VALUES
(
  'expansion_center',
  'Expansion center',
  'Defines the point around which powers are measured.',
  'Identifies the local operating condition for interpretation.',
  'A power-series approximation should not be interpreted without knowing its center.'
);

INSERT INTO power_series_assumption_registry VALUES
(
  'radius_of_convergence',
  'Radius of convergence',
  'Defines where the infinite series converges around the center.',
  'Sets a mathematical boundary for functional representation.',
  'Computing outside the convergence radius does not justify interpretation.'
);

INSERT INTO power_series_assumption_registry VALUES
(
  'coefficient_rule',
  'Coefficient rule',
  'Explains how the series coefficients are generated.',
  'Distinguishes Taylor-derived coefficients from fitted or assumed coefficients.',
  'Coefficients without provenance are difficult to audit.'
);

INSERT INTO power_series_assumption_registry VALUES
(
  'truncation_order',
  'Truncation order',
  'Records how many terms are retained in the finite approximation.',
  'Separates the computed polynomial from the infinite representation.',
  'A finite truncation is not the same as the full function.'
);

INSERT INTO power_series_assumption_registry VALUES
(
  'remainder_logic',
  'Remainder logic',
  'Documents the omitted terms or error estimate.',
  'Supports responsible use of finite polynomial approximations.',
  'A polynomial approximation should not be trusted without error or validity review.'
);

SELECT
    assumption_name,
    mathematical_role,
    systems_modeling_role,
    review_warning
FROM power_series_assumption_registry
ORDER BY assumption_key;

This registry keeps power-series interpretation tied to center, convergence radius, coefficient provenance, truncation order, and remainder logic.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports power-series approximation audits, coefficient interpretation, convergence-radius checks, finite truncation diagnostics, geometric-series examples, local approximation records, SQL assumption registries, generated outputs, advanced mathematical audit reports, and website-ready calculator scaffolding.

Back to top ↑

Interpretive Limits and Responsible Use

Power series are powerful because they can turn complex functions into structured polynomial representations. They are also easy to overuse. A power series may converge only locally. A Taylor series may not equal the original function. A finite truncation may be accurate near the center and poor farther away. Endpoint behavior may differ from interior behavior. A polynomial may produce plausible values outside the domain where it has mathematical support.

Responsible use requires several checks. State the expansion center. Identify the coefficient rule. Report the number of terms retained. State the radius or interval of convergence when known. Check whether evaluation points lie inside the valid interval. Estimate or bound truncation error where possible. Avoid treating a local approximation as a global model. Distinguish fitted polynomial models from power-series representations derived from a function.

The central modeling question is not only “Can this function be represented by a power series?” It is “Where does the representation converge, what does the finite truncation preserve, what does it omit, and how far from the center can the approximation be trusted?”

Back to top ↑

Related Articles

• Calculus for Systems Modeling
• Convergence Tests and the Discipline of Infinite Approximation
• Sequences, Series, and the Logic of Convergence
• Taylor and Maclaurin Series in Modeling
• Approximation Error, Truncation, and Local Validity
• Limits and the Formal Basis of Calculus
• Differentiability and Local Behavior
• Scientific Computing for Systems Modeling
• Numerical Methods for Systems Modeling
• Model Governance and Accountability

Back to top ↑

Further Reading

• Abbott, S. (2015) Understanding Analysis. 2nd edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-1-4939-2712-8.
• Apostol, T.M. (1967) Calculus, Volume 1: One-Variable Calculus, with an Introduction to Linear Algebra. 2nd edn. New York: Wiley. Available at: https://www.wiley.com/en-us/Calculus%2C+Volume+1%2C+2nd+Edition-p-9780471000051.
• Apostol, T.M. (1969) Calculus, Volume 2: Multi-Variable Calculus and Linear Algebra, with Applications to Differential Equations and Probability. 2nd edn. New York: Wiley. Available at: https://www.wiley.com/en-us/Calculus%2C+Volume+2%2C+2nd+Edition-p-9780471000075.
• Courant, R. and John, F. (1999) Introduction to Calculus and Analysis, Volume I. Berlin: Springer. Available at: https://link.springer.com/book/10.1007/978-3-642-58604-0.
• Knopp, K. (1990) Theory and Application of Infinite Series. New York: Dover Publications. Available at: https://store.doverpublications.com/products/9780486661650.
• Rudin, W. (1976) Principles of Mathematical Analysis. 3rd edn. New York: McGraw-Hill. Available at: https://www.mheducation.com/highered/product/principles-mathematical-analysis-rudin/M9780070542358.html.
• Spivak, M. (2008) Calculus. 4th edn. Houston, TX: Publish or Perish. Available at: https://www.publishorperish.com/Calculus.
• Stein, E.M. and Shakarchi, R. (2003) Complex Analysis. Princeton, NJ: Princeton University Press. Available at: https://press.princeton.edu/books/hardcover/9780691113852/complex-analysis.
• Trefethen, L.N. (2013) Approximation Theory and Approximation Practice. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611972405.
• Burden, R.L., Faires, J.D. and Burden, A.M. (2015) Numerical Analysis. 10th edn. Boston, MA: Cengage Learning. Available at: https://www.cengage.com/c/numerical-analysis-10e-burden/.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718027.
• National Institute of Standards and Technology (n.d.) DLMF: Chapter 1, Algebraic and Analytic Methods. NIST Digital Library of Mathematical Functions. Available at: https://dlmf.nist.gov/1.
• National Institute of Standards and Technology (n.d.) DLMF: Chapter 2, Asymptotic Approximations. NIST Digital Library of Mathematical Functions. Available at: https://dlmf.nist.gov/2.
• Massachusetts Institute of Technology OpenCourseWare (2010) Single Variable Calculus. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-01sc-single-variable-calculus-fall-2010/.
• Massachusetts Institute of Technology OpenCourseWare (2011) Differential Equations. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-03sc-differential-equations-fall-2011/.
• OpenStax (2016) Calculus Volume 2. Houston, TX: OpenStax, Rice University. Available at: https://openstax.org/details/books/calculus-volume-2.
• SciPy Developers (n.d.) Special Functions: scipy.special. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/special.html.
• NumPy Developers (n.d.) Polynomials. NumPy Documentation. Available at: https://numpy.org/doc/stable/reference/routines.polynomials.html.

Back to top ↑

References

• Abbott, S. (2015) Understanding Analysis. 2nd edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-1-4939-2712-8.
• Apostol, T.M. (1967) Calculus, Volume 1: One-Variable Calculus, with an Introduction to Linear Algebra. 2nd edn. New York: Wiley. Available at: https://www.wiley.com/en-us/Calculus%2C+Volume+1%2C+2nd+Edition-p-9780471000051.
• Apostol, T.M. (1969) Calculus, Volume 2: Multi-Variable Calculus and Linear Algebra, with Applications to Differential Equations and Probability. 2nd edn. New York: Wiley. Available at: https://www.wiley.com/en-us/Calculus%2C+Volume+2%2C+2nd+Edition-p-9780471000075.
• Burden, R.L., Faires, J.D. and Burden, A.M. (2015) Numerical Analysis. 10th edn. Boston, MA: Cengage Learning. Available at: https://www.cengage.com/c/numerical-analysis-10e-burden/.
• Courant, R. and John, F. (1999) Introduction to Calculus and Analysis, Volume I. Berlin: Springer. Available at: https://link.springer.com/book/10.1007/978-3-642-58604-0.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718027.
• Knopp, K. (1990) Theory and Application of Infinite Series. New York: Dover Publications. Available at: https://store.doverpublications.com/products/9780486661650.
• Massachusetts Institute of Technology OpenCourseWare (2010) Single Variable Calculus. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-01sc-single-variable-calculus-fall-2010/.
• Massachusetts Institute of Technology OpenCourseWare (2011) Differential Equations. Cambridge, MA: MIT OpenCourseWare. Available at: https://ocw.mit.edu/courses/18-03sc-differential-equations-fall-2011/.
• National Institute of Standards and Technology (n.d.) DLMF: Chapter 1, Algebraic and Analytic Methods. NIST Digital Library of Mathematical Functions. Available at: https://dlmf.nist.gov/1.
• National Institute of Standards and Technology (n.d.) DLMF: Chapter 2, Asymptotic Approximations. NIST Digital Library of Mathematical Functions. Available at: https://dlmf.nist.gov/2.
• OpenStax (2016) Calculus Volume 2. Houston, TX: OpenStax, Rice University. Available at: https://openstax.org/details/books/calculus-volume-2.
• Rudin, W. (1976) Principles of Mathematical Analysis. 3rd edn. New York: McGraw-Hill. Available at: https://www.mheducation.com/highered/product/principles-mathematical-analysis-rudin/M9780070542358.html.
• Spivak, M. (2008) Calculus. 4th edn. Houston, TX: Publish or Perish. Available at: https://www.publishorperish.com/Calculus.
• Stein, E.M. and Shakarchi, R. (2003) Complex Analysis. Princeton, NJ: Princeton University Press. Available at: https://press.princeton.edu/books/hardcover/9780691113852/complex-analysis.
• Trefethen, L.N. (2013) Approximation Theory and Approximation Practice. Philadelphia, PA: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611972405.

Back to top ↑