Calculus Class with methods pertaining to basic operations. More...

#include <differential.hpp>

Public Member Functions
Differential	operator+ (const Differential &other) const
	Overloaded addition operator for Differential objects. More...

Differential	operator* (const Differential &other) const
	Overloaded multiplication operator for Differential objects. More...

void	add_term (double coefficient, int exponent)
	Adds a term to the Differential object. More...

void	display () const
	Displays the polynomial in a readable format. More...

Differential	power_rule () const
	Computes the derivative using the power rule. More...

Differential	product_rule (const Differential &other) const
	Computes the derivative using the product rule. More...

Differential	quotient_rule (const Differential &other) const
	Computes the derivative using the quotient rule. More...

Differential	chain_rule (const Differential &inner) const
	Computes the derivative using the chain rule. More...

Differential	nth_derivative (int n) const
	Computes the nth derivative of the current Differential object. More...

double	eval (double x) const
	Evaluates the polynomial for a given value of x. More...

double	limit_at (double x) const
	Calculate the limit of the polynomial at a specific point. More...

double	limit_at_infinity () const
	Calculate the limit of the polynomial as x approaches infinity. More...

Public Attributes
std::vector< Term >	terms

Detailed Description

Calculus Class with methods pertaining to basic operations.

Examples: deriv.cpp.

Definition at line 67 of file differential.hpp.

Member Function Documentation

◆ add_term()

void gpmp::Differential::add_term	(	double	coefficient,
		int	exponent
	)

Adds a term to the Differential object.

Parameters

coefficient	The coefficient of the term to add
exponent	The exponent of the term to add

Examples: deriv.cpp.

Definition at line 45 of file differential.cpp.

                                                                 {
     terms.emplace_back(coefficient, exponent);
 }

References terms.

Referenced by chain_rule(), main(), and power_rule().

◆ chain_rule()

gpmp::Differential gpmp::Differential::chain_rule ( const Differential & inner ) const

Computes the derivative using the chain rule.

Parameters

inner The inner function for the chain rule

Returns: The derivative of the composite function

Examples: deriv.cpp.

Definition at line 80 of file differential.cpp.

                                                                 {
     gpmp::Differential result;
  
     for (const auto &outer_term : terms) {
         // Apply the chain rule to each term of the outer function
         gpmp::Differential inner_derivative = inner.power_rule();
  
         // Multiply each term of inner_derivative by the coefficient of the
         // outer term
         for (auto &inner_term : inner_derivative.terms) {
             inner_term.coefficient *= outer_term.coefficient;
         }
  
         // Multiply the inner derivative by the derivative of the outer term
         for (const auto &inner_term : inner_derivative.terms) {
             double new_coefficient = inner_term.coefficient;
             int new_exponent = outer_term.exponent + inner_term.exponent;
             result.add_term(new_coefficient, new_exponent);
         }
     }
  
     return result;
 }

References add_term(), power_rule(), and terms.

Referenced by main().

◆ display()

void gpmp::Differential::display ( ) const

Displays the polynomial in a readable format.

Examples: deriv.cpp.

Definition at line 49 of file differential.cpp.

                                      {
     for (size_t i = 0; i < terms.size(); ++i) {
         const auto &term = terms[i];
         if (term.exponent > 1) {
             std::cout << term.coefficient << "*x^" << term.exponent;
         } else if (term.exponent == 1) {
             std::cout << term.coefficient << "*x";
         } else {
             std::cout << term.coefficient;
         }
  
         if (i < terms.size() - 1) {
             std::cout << " + ";
         }
     }
     std::cout << std::endl;
 }

Referenced by main().

◆ eval()

double gpmp::Differential::eval ( double x ) const

Evaluates the polynomial for a given value of x.

Parameters

x	The value at which to evaluate the polynomial

Returns: The result of evaluating the polynomial at x

Examples: deriv.cpp.

Definition at line 112 of file differential.cpp.

                                             {
     double result = 0.0;
     for (const auto &term : terms) {
         result += term.coefficient * std::pow(x, term.exponent);
     }
     return result;
 }

Referenced by main().

◆ limit_at()

double gpmp::Differential::limit_at ( double x ) const

Calculate the limit of the polynomial at a specific point.

This method calculates the limit of the polynomial at a specific point by evaluating the polynomial at that point The limit is undefined if the polynomial has a term with a positive exponent at the highest degree

Parameters

x	The point at which to calculate the limit

Returns: The limit of the polynomial at the specified point

Examples: deriv.cpp.

Definition at line 120 of file differential.cpp.

                                                 {
     double result = 0.0;
  
     for (const auto &term : terms) {
         result += term.coefficient * std::pow(x, term.exponent);
     }
  
     return result;
 }

Referenced by main().

◆ limit_at_infinity()

double gpmp::Differential::limit_at_infinity ( ) const

Calculate the limit of the polynomial as x approaches infinity.

This method calculates the limit of the polynomial as x approaches infinity by examining the term with the highest exponent The limit is infinity or negative infinity if the highest exponent is greater than zero Otherwise, the limit is the constant term

Returns: The limit of the polynomial as x approaches infinity

Examples: deriv.cpp.

Definition at line 130 of file differential.cpp.

                                                  {
     // Calculate the limit as x approaches infinity using the highest exponent
     // term
     if (!terms.empty()) {
         const auto &highest_term =
             *std::max_element(terms.begin(),
                               terms.end(),
                               [](const auto &a, const auto &b) {
                                   return a.exponent < b.exponent;
                               });
  
         if (highest_term.exponent > 0) {
             // If the highest term has a positive exponent, the limit is
             // infinity or negative infinity
             return (highest_term.coefficient > 0)
                        ? std::numeric_limits<double>::infinity()
                        : -std::numeric_limits<double>::infinity();
         } else {
             // If the highest term has a zero exponent, the limit is the
             // constant term
             return highest_term.coefficient;
         }
     }
  
     // If the differential is empty, the limit is undefined
     return std::numeric_limits<double>::quiet_NaN();
 }

Referenced by main().

◆ nth_derivative()

gpmp::Differential gpmp::Differential::nth_derivative ( int n ) const

Computes the nth derivative of the current Differential object.

Parameters

n	The order of the derivative to compute

Returns: The nth derivative of the current Differential object

Definition at line 104 of file differential.cpp.

                                                              {
     gpmp::Differential result = *this;
     for (int i = 0; i < n; ++i) {
         result = result.power_rule();
     }
     return result;
 }

References power_rule().

◆ operator*()

Differential gpmp::Differential::operator* ( const Differential & other ) const

Overloaded multiplication operator for Differential objects.

Parameters

other The Differential object to multiply

Returns: The product of two Differential objects

◆ operator+()

Differential gpmp::Differential::operator+ ( const Differential & other ) const

Overloaded addition operator for Differential objects.

Parameters

other The Differential object to add

Returns: The sum of two Differential objects

◆ power_rule()

gpmp::Differential gpmp::Differential::power_rule ( ) const

Computes the derivative using the power rule.

Returns: The derivative of the current Differential object

Examples: deriv.cpp.

Definition at line 67 of file differential.cpp.

                                                     {
     gpmp::Differential result;
     for (const auto &term : terms) {
         if (term.exponent > 0) {
             double new_coefficient = term.coefficient * term.exponent;
             int new_exponent = term.exponent - 1;
             result.add_term(new_coefficient, new_exponent);
         }
     }
     return result;
 }

References add_term().

Referenced by chain_rule(), main(), and nth_derivative().

◆ product_rule()

Differential gpmp::Differential::product_rule ( const Differential & other ) const

Computes the derivative using the product rule.

Parameters

other The other Differential object in the product

Returns: The derivative of the product of two Differential objects

◆ quotient_rule()

Differential gpmp::Differential::quotient_rule ( const Differential & other ) const

Computes the derivative using the quotient rule.

Parameters

other The other Differential object in the quotient

Returns: The derivative of the quotient of two Differential objects

Member Data Documentation

◆ terms

std::vector<Term> gpmp::Differential::terms

Vector of terms representing the polynomial

Definition at line 69 of file differential.hpp.

Referenced by add_term(), and chain_rule().

The documentation for this class was generated from the following files:

include/openGPMP/calculus/differential.hpp
modules/calculus/differential.cpp

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

◆ add_term()

◆ chain_rule()

◆ display()

◆ eval()

◆ limit_at()

◆ limit_at_infinity()

◆ nth_derivative()

◆ operator*()

◆ operator+()

◆ power_rule()

◆ product_rule()

◆ quotient_rule()

Member Data Documentation

◆ terms