def exponential_roots_initial_value(first_constant, second_constant, initial_value, precision = 4):
# Handle input errors
three_scalars(first_constant, second_constant, initial_value)
positive_integer(precision)
# Create list to return
result = []
# Create intermediary variables
numerator = log(abs(initial_value / first_constant))
denominator = log(abs(second_constant))
# Circumvent division by zero
if denominator == 0:
denominator = 10**(-precision)
# Determine root given an initial value
ratio = numerator / denominator
# Round root
rounded_ratio = rounded_value(ratio, precision)
# Return result
result.append(rounded_ratio)
return result
def logarithmic_roots_derivative_initial_value(first_constant,
second_constant,
initial_value,
precision=4):
# Handle input errors
three_scalars(first_constant, second_constant, initial_value)
positive_integer(precision)
# Determine roots of derivative given an initial value
result = hyperbolic_roots(first_constant, -1 * initial_value, precision)
return result
def linear_roots_initial_value(first_constant,
second_constant,
initial_value,
precision=4):
# Handle input errors
three_scalars(first_constant, second_constant, initial_value)
positive_integer(precision)
# Determine roots given an initial value
result = linear_roots(first_constant, second_constant - initial_value,
precision)
return result
def exponential_roots_derivative_initial_value(first_constant, second_constant, initial_value, precision = 4):
# Handle input errors
three_scalars(first_constant, second_constant, initial_value)
positive_integer(precision)
# Circumvent division by zero
denominator = log(abs(second_constant))
if denominator == 0:
denominator = 10**(-precision)
# Determine root of derivative given an initial value
result = exponential_roots_initial_value(first_constant * denominator, second_constant, initial_value, precision)
return result
def quadratic_roots_first_derivative(first_constant,
second_constant,
third_constant,
precision=4):
# Handle input errors
three_scalars(first_constant, second_constant, third_constant)
positive_integer(precision)
# Generate coefficients of first derivative
constants = quadratic_derivatives(first_constant, second_constant,
third_constant)['first']['constants']
# Determine roots of first derivative
result = linear_roots(*constants, precision)
return result
def quadratic_roots_second_derivative(first_constant,
second_constant,
third_constant,
precision=4):
# Handle input errors
three_scalars(first_constant, second_constant, third_constant)
positive_integer(precision)
# Create list to return
result = []
# Determine root
root = None
# Return result
result.append(root)
return result
def logistic_roots_second_derivative(first_constant,
second_constant,
third_constant,
precision=4):
# Handle input errors
three_scalars(first_constant, second_constant, third_constant)
positive_integer(precision)
# Create list to return
result = []
# Determine root of second derivative
root = rounded_value(third_constant)
# Return root
result.append(root)
return result
def linear_roots_derivative_initial_value(first_constant,
second_constant,
initial_value,
precision=4):
# Handle input errors
three_scalars(first_constant, second_constant, initial_value)
positive_integer(precision)
# Create list to return
result = []
# Handle general case
if initial_value == first_constant:
result.append('All')
# Handle exception
else:
result.append(None)
# Return result
return result
def hyperbolic_roots_derivative_initial_value(first_constant,
second_constant,
initial_value,
precision=4):
# Handle input errors
three_scalars(first_constant, second_constant, initial_value)
positive_integer(precision)
# Create list to return
result = []
# Create intermediary variable
ratio = -1 * first_constant / initial_value
# Handle no roots
if ratio < 0:
result.append(None)
# Determine roots of derivative given an initial value
else:
radical = ratio**(1 / 2)
rounded_radical = rounded_value(radical, precision)
result.append(rounded_radical)
return result
def logistic_equation(first_constant, second_constant, third_constant, precision = 4):
"""
Generates a logistic function to provide evaluations at variable inputs
Parameters
----------
first_constant : int or float
Carrying capacity of the resultant logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
second_constant : int or float
Growth rate of the resultant logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
third_constant : int or float
Value of the sigmoid's midpoint of the resultant logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
precision : int, default=4
Maximum number of digits that can appear after the decimal place of the resultant roots
Raises
------
TypeError
First three arguments must be integers or floats
ValueError
Last argument must be a positive integer
Returns
-------
evaluation : func
Function for evaluating a logistic equation when passed any integer or float argument
See Also
--------
:func:`~regressions.analyses.derivatives.logistic.logistic_derivatives`, :func:`~regressions.analyses.integrals.logistic.logistic_integral`, :func:`~regressions.analyses.roots.logistic.logistic_roots`, :func:`~regressions.models.logistic.logistic_model`
Notes
-----
- Standard form of a logistic function: :math:`f(x) = \\frac{a}{1 + \\text{e}^{-b\\cdot(x - c)}}`
- |logistic_functions|
Examples
--------
Import `logistic_equation` function from `regressions` library
>>> from regressions.analyses.equations.logistic import logistic_equation
Create a logistic function with coefficients 2, 3, and 5, then evaluate it at 10
>>> evaluation_first = logistic_equation(2, 3, 5)
>>> print(evaluation_first(10))
2.0
Create a logistic function with coefficients 100, 5, and 11, then evaluate it at 10
>>> evaluation_second = logistic_equation(100, 5, 11)
>>> print(evaluation_second(10))
0.6693
Create a logistic function with all inputs set to 0, then evaluate it at 10
>>> evaluation_zero = logistic_equation(0, 0, 0)
>>> print(evaluation_zero(10))
0.0001
"""
# Handle input errors
three_scalars(first_constant, second_constant, third_constant)
positive_integer(precision)
coefficients = no_zeroes([first_constant, second_constant, third_constant], precision)
# Create evaluation
def logistic_evaluation(variable):
evaluation = coefficients[0] * (1 + exp(-1 * coefficients[1] * (variable - coefficients[2])))**(-1)
result = rounded_value(evaluation, precision)
return result
return logistic_evaluation
def quadratic_derivatives(first_constant,
second_constant,
third_constant,
precision=4):
"""
Calculates the first and second derivatives of a quadratic function
Parameters
----------
first_constant : int or float
Coefficient of the quadratic term of the original quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
second_constant : int or float
Coefficient of the linear term of the original quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
third_constant : int or float
Coefficient of the constant term of the original quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
precision : int, default=4
Maximum number of digits that can appear after the decimal place of the resultant roots
Raises
------
TypeError
First three arguments must be integers or floats
ValueError
Last argument must be a positive integer
Returns
-------
derivatives['first']['constants'] : list of float
Coefficients of the resultant first derivative
derivatives['first']['evaluation'] : func
Function for evaluating the resultant first derivative at any float or integer argument
derivatives['second']['constants'] : list of float
Coefficients of the resultant second derivative
derivatives['second']['evaluation'] : func
Function for evaluating the resultant second derivative at any float or integer argument
See Also
--------
:func:`~regressions.analyses.equations.quadratic.quadratic_equation`, :func:`~regressions.analyses.integrals.quadratic.quadratic_integral`, :func:`~regressions.analyses.roots.quadratic.quadratic_roots`, :func:`~regressions.models.quadratic.quadratic_model`
Notes
-----
- Standard form of a quadratic function: :math:`f(x) = a\\cdot{x^2} + b\\cdot{x} + c`
- First derivative of a quadratic function: :math:`f'(x) = 2a\\cdot{x} + b`
- Second derivative of a quadratic function: :math:`f''(x) = 2a`
- |differentiation_formulas|
Examples
--------
Import `quadratic_derivatives` function from `regressions` library
>>> from regressions.analyses.derivatives.quadratic import quadratic_derivatives
Generate the derivatives of a quadratic function with coefficients 2, 3, and 5, then display the coefficients of its first and second derivatives
>>> derivatives_constants = quadratic_derivatives(2, 3, 5)
>>> print(derivatives_constants['first']['constants'])
[4.0, 3.0]
>>> print(derivatives_constants['second']['constants'])
[4.0]
Generate the derivatives of a quadratic function with coefficients 7, -5, and 3, then evaluate its first and second derivatives at 10
>>> derivatives_evaluation = quadratic_derivatives(7, -5, 3)
>>> print(derivatives_evaluation['first']['evaluation'](10))
135.0
>>> print(derivatives_evaluation['second']['evaluation'](10))
14.0
Generate the derivatives of a quadratic function with all inputs set to 0, then display the coefficients of its first and second derivatives
>>> derivatives_zeroes = quadratic_derivatives(0, 0, 0)
>>> print(derivatives_zeroes['first']['constants'])
[0.0002, 0.0001]
>>> print(derivatives_zeroes['second']['constants'])
[0.0002]
"""
# Handle input errors
three_scalars(first_constant, second_constant, third_constant)
positive_integer(precision)
coefficients = no_zeroes([first_constant, second_constant, third_constant],
precision)
# Create first derivative
first_constants = [2 * coefficients[0], coefficients[1]]
def first_derivative(variable):
evaluation = first_constants[0] * variable + first_constants[1]
rounded_evaluation = rounded_value(evaluation, precision)
return rounded_evaluation
first_dictionary = {
'constants': first_constants,
'evaluation': first_derivative
}
# Create second derivative
second_constants = [first_constants[0]]
def second_derivative(variable):
evaluation = second_constants[0]
rounded_evaluation = rounded_value(evaluation, precision)
return rounded_evaluation
second_dictionary = {
'constants': second_constants,
'evaluation': second_derivative
}
# Package both derivatives in single dictionary
results = {'first': first_dictionary, 'second': second_dictionary}
return results
def quadratic_equation(first_constant,
second_constant,
third_constant,
precision=4):
"""
Generates a quadratic function to provide evaluations at variable inputs
Parameters
----------
first_constant : int or float
Coefficient of the quadratic term of the resultant quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
second_constant : int or float
Coefficient of the linear term of the resultant quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
third_constant : int or float
Coefficient of the constant term of the resultant quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
precision : int, default=4
Maximum number of digits that can appear after the decimal place of the resultant roots
Raises
------
TypeError
First three arguments must be integers or floats
ValueError
Last argument must be a positive integer
Returns
-------
evaluation : func
Function for evaluating a quadratic equation when passed any integer or float argument
See Also
--------
:func:`~regressions.analyses.derivatives.quadratic.quadratic_derivatives`, :func:`~regressions.analyses.integrals.quadratic.quadratic_integral`, :func:`~regressions.analyses.roots.quadratic.quadratic_roots`, :func:`~regressions.models.quadratic.quadratic_model`
Notes
-----
- Standard form of a quadratic function: :math:`f(x) = a\\cdot{x^2} + b\\cdot{x} + c`
- |quadratic_functions|
Examples
--------
Import `quadratic_equation` function from `regressions` library
>>> from regressions.analyses.equations.quadratic import quadratic_equation
Create a quadratic function with coefficients 2, 3, and 5, then evaluate it at 10
>>> evaluation_first = quadratic_equation(2, 3, 5)
>>> print(evaluation_first(10))
235.0
Create a quadratic function with coefficients 7, -5, and 3, then evaluate it at 10
>>> evaluation_second = quadratic_equation(7, -5, 3)
>>> print(evaluation_second(10))
653.0
Create a quadratic function with all inputs set to 0, then evaluate it at 10
>>> evaluation_zero = quadratic_equation(0, 0, 0)
>>> print(evaluation_zero(10))
0.0111
"""
# Handle input errors
three_scalars(first_constant, second_constant, third_constant)
positive_integer(precision)
coefficients = no_zeroes([first_constant, second_constant, third_constant],
precision)
# Create evaluation
def quadratic_evaluation(variable):
evaluation = coefficients[0] * variable**2 + coefficients[
1] * variable + coefficients[2]
result = rounded_value(evaluation, precision)
return result
return quadratic_evaluation
def logistic_roots(first_constant,
second_constant,
third_constant,
precision=4):
"""
Calculates the roots of a logistic function
Parameters
----------
first_constant : int or float
Carrying capacity of the original logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
second_constant : int or float
Growth rate of the original logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
third_constant : int or float
Value of the sigmoid's midpoint of the original logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
precision : int, default=4
Maximum number of digits that can appear after the decimal place of the resultant roots
Raises
------
TypeError
First three arguments must be integers or floats
ValueError
Last argument must be a positive integer
Returns
-------
roots : list of float
List of the x-coordinates of all of the x-intercepts of the original function; if the function never crosses the x-axis, then it will return a list of `None`
See Also
--------
:func:`~regressions.analyses.equations.logistic.logistic_equation`, :func:`~regressions.analyses.derivatives.logistic.logistic_derivatives`, :func:`~regressions.analyses.integrals.logistic.logistic_integral`, :func:`~regressions.models.logistic.logistic_model`
Notes
-----
- Standard form of a logistic function: :math:`f(x) = \\frac{a}{1 + \\text{e}^{-b\\cdot(x - c)}}`
- Logistic formula: :math:`x = \\varnothing`
Examples
--------
Import `logistic_roots` function from `regressions` library
>>> from regressions.analyses.roots.logistic import logistic_roots
Calculate the roots of a logistic function with coefficients 2, 3, and 5
>>> roots_first = logistic_roots(2, 3, 5)
>>> print(roots_first)
[None]
Calculate the roots of a logistic function with coefficients 100, 5, and 11
>>> roots_second = logistic_roots(100, 5, 11)
>>> print(roots_second)
[None]
Calculate the roots of a logistic function with all inputs set to 0
>>> roots_zeroes = logistic_roots(0, 0, 0)
>>> print(roots_zeroes)
[None]
"""
# Handle input errors
three_scalars(first_constant, second_constant, third_constant)
positive_integer(precision)
coefficients = no_zeroes([first_constant, second_constant, third_constant],
precision)
# Create list to return
result = []
# Determine root
root = None
# Return result
result.append(root)
return result
def logistic_derivatives(first_constant,
second_constant,
third_constant,
precision=4):
"""
Calculates the first and second derivatives of a logistic function
Parameters
----------
first_constant : int or float
Carrying capacity of the original logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
second_constant : int or float
Growth rate of the original logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
third_constant : int or float
Value of the sigmoid's midpoint of the original logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
precision : int, default=4
Maximum number of digits that can appear after the decimal place of the resultant roots
Raises
------
TypeError
First three arguments must be integers or floats
ValueError
Last argument must be a positive integer
Returns
-------
derivatives['first']['constants'] : list of float
Coefficients of the resultant first derivative
derivatives['first']['evaluation'] : func
Function for evaluating the resultant first derivative at any float or integer argument
derivatives['second']['constants'] : list of float
Coefficients of the resultant second derivative
derivatives['second']['evaluation'] : func
Function for evaluating the resultant second derivative at any float or integer argument
See Also
--------
:func:`~regressions.analyses.equations.logistic.logistic_equation`, :func:`~regressions.analyses.integrals.logistic.logistic_integral`, :func:`~regressions.analyses.roots.logistic.logistic_roots`, :func:`~regressions.models.logistic.logistic_model`
Notes
-----
- Standard form of a logistic function: :math:`f(x) = \\frac{a}{1 + \\text{e}^{-b\\cdot(x - c)}}`
- First derivative of a logistic function: :math:`f'(x) = \\frac{ab\\cdot{\\text{e}^{-b\\cdot(x - c)}}}{(1 + \\text{e}^{-b\\cdot(x - c)})^2}`
- Second derivative of a logistic function: :math:`f''(x) = \\frac{2ab^2\\cdot{\\text{e}^{-2b\\cdot(x - c)}}}{(1 + \\text{e}^{-b\\cdot(x - c)})^3} - \\frac{ab^2\\cdot{\\text{e}^{-b\\cdot(x - c)}}}{(1 + \\text{e}^{-b\\cdot(x - c)})^2}`
- |differentiation_formulas|
- |chain_rule|
- |exponential|
Examples
--------
Import `logistic_derivatives` function from `regressions` library
>>> from regressions.analyses.derivatives.logistic import logistic_derivatives
Generate the derivatives of a logistic function with coefficients 2, 3, and 5, then display the coefficients of its first and second derivatives
>>> derivatives_constants = logistic_derivatives(2, 3, 5)
>>> print(derivatives_constants['first']['constants'])
[6.0, 3.0, 5.0]
>>> print(derivatives_constants['second']['constants'])
[18.0, 3.0, 5.0]
Generate the derivatives of a logistic function with coefficients 100, 5, and 11, then evaluate its first and second derivatives at 10
>>> derivatives_evaluation = logistic_derivatives(100, 5, 11)
>>> print(derivatives_evaluation['first']['evaluation'](10))
3.324
>>> print(derivatives_evaluation['second']['evaluation'](10))
16.3977
Generate the derivatives of a logistic function with all inputs set to 0, then display the coefficients of its first and second derivatives
>>> derivatives_zeroes = logistic_derivatives(0, 0, 0)
>>> print(derivatives_zeroes['first']['constants'])
[0.0001, 0.0001, 0.0001]
>>> print(derivatives_zeroes['second']['constants'])
[0.0001, 0.0001, 0.0001]
"""
# Handle input errors
three_scalars(first_constant, second_constant, third_constant)
positive_integer(precision)
coefficients = no_zeroes([first_constant, second_constant, third_constant],
precision)
# Create first derivative
first_coefficients = [
coefficients[0] * coefficients[1], coefficients[1], coefficients[2]
]
first_constants = rounded_list(first_coefficients, precision)
def first_derivative(variable):
exponential = exp(-1 * first_constants[1] *
(variable - first_constants[2]))
evaluation = first_constants[0] * exponential * (1 + exponential)**(-2)
rounded_evaluation = rounded_value(evaluation, precision)
return rounded_evaluation
first_dictionary = {
'constants': first_constants,
'evaluation': first_derivative
}
# Create second derivative
second_coefficients = [
first_constants[0] * first_constants[1], first_constants[1],
first_constants[2]
]
second_constants = rounded_list(second_coefficients, precision)
def second_derivative(variable):
exponential = exp(-1 * second_constants[1] *
(variable - second_constants[2]))
evaluation = second_constants[0] * exponential * (1 + exponential)**(
-2) * (2 * exponential / (1 + exponential) - 1)
rounded_evaluation = rounded_value(evaluation, precision)
return rounded_evaluation
second_dictionary = {
'constants': second_constants,
'evaluation': second_derivative
}
# Package both derivatives in single dictionary
results = {'first': first_dictionary, 'second': second_dictionary}
return results
def logistic_integral(first_constant,
second_constant,
third_constant,
precision=4):
"""
Generates the integral of a logistic function
Parameters
----------
first_constant : int or float
Carrying capacity of the original logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
second_constant : int or float
Growth rate of the original logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
third_constant : int or float
Value of the sigmoid's midpoint of the original logistic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
precision : int, default=4
Maximum number of digits that can appear after the decimal place of the resultant roots
Raises
------
TypeError
First three arguments must be integers or floats
ValueError
Last argument must be a positive integer
Returns
-------
integral['constants'] : list of float
Coefficients of the resultant integral
integral['evaluation'] : func
Function for evaluating the resultant integral at any float or integer argument
See Also
--------
:func:`~regressions.analyses.equations.logistic.logistic_equation`, :func:`~regressions.analyses.derivatives.logistic.logistic_derivatives`, :func:`~regressions.analyses.roots.logistic.logistic_roots`, :func:`~regressions.models.logistic.logistic_model`
Notes
-----
- Standard form of a logistic function: :math:`f(x) = \\frac{a}{1 + \\text{e}^{-b\\cdot(x - c)}}`
- Integral of a logistic function: :math:`F(x) = \\frac{a}{b}\\cdot{\\ln|\\text{e}^{b\\cdot(x - c)} + 1|}`
- |indefinite_integral|
- |integration_formulas|
- |substitution_rule|
Examples
--------
Import `logistic_integral` function from `regressions` library
>>> from regressions.analyses.integrals.logistic import logistic_integral
Generate the integral of a logistic function with coefficients 2, 3, and 5, then display its coefficients
>>> integral_constants = logistic_integral(2, 3, 5)
>>> print(integral_constants['constants'])
[0.6667, 3.0, 5.0]
Generate the integral of a logistic function with coefficients 100, 5, and 11, then evaluate its integral at 10
>>> integral_evaluation = logistic_integral(100, 5, 11)
>>> print(integral_evaluation['evaluation'](10))
0.1343
Generate the integral of a logistic function with all inputs set to 0, then display its coefficients
>>> integral_zeroes = logistic_integral(0, 0, 0)
>>> print(integral_zeroes['constants'])
[1.0, 0.0001, 0.0001]
"""
# Handle input errors
three_scalars(first_constant, second_constant, third_constant)
positive_integer(precision)
coefficients = no_zeroes([first_constant, second_constant, third_constant],
precision)
# Create constants
integral_coefficients = [
coefficients[0] / coefficients[1], coefficients[1], coefficients[2]
]
constants = rounded_list(integral_coefficients, precision)
# Create evaluation
def logistic_evaluation(variable):
evaluation = constants[0] * log(
abs(exp(constants[1] * (variable - constants[2])) + 1))
rounded_evaluation = rounded_value(evaluation, precision)
return rounded_evaluation
# Package constants and evaluation in single dictionary
results = {'constants': constants, 'evaluation': logistic_evaluation}
return results
def test_three_scalars_integer_float_whole(self):
three_scalars_integer_float_whole = three_scalars(
good_integer, good_float, good_whole)
self.assertEqual(
three_scalars_integer_float_whole,
'First, second, and third arguments are all integers or floats')
def test_three_scalars_integer_float_string_raises(self):
with self.assertRaises(Exception) as context:
three_scalars(good_integer, good_float, bad_scalar)
self.assertEqual(type(context.exception), TypeError)
self.assertEqual(str(context.exception),
'Third argument must be an integer or a float')
def quadratic_roots(first_constant,
second_constant,
third_constant,
precision=4):
"""
Calculates the roots of a quadratic function
Parameters
----------
first_constant : int or float
Coefficient of the quadratic term of the original quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
second_constant : int or float
Coefficient of the linear term of the original quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
third_constant : int or float
Coefficient of the constant term of the original quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
precision : int, default=4
Maximum number of digits that can appear after the decimal place of the resultant roots
Raises
------
TypeError
First three arguments must be integers or floats
ValueError
Last argument must be a positive integer
Returns
-------
roots : list of float
List of the x-coordinates of all of the x-intercepts of the original function; if the function never crosses the x-axis, then it will return a list of `None`
See Also
--------
:func:`~regressions.analyses.equations.quadratic.quadratic_equation`, :func:`~regressions.analyses.derivatives.quadratic.quadratic_derivatives`, :func:`~regressions.analyses.integrals.quadratic.quadratic_integral`, :func:`~regressions.models.quadratic.quadratic_model`
Notes
-----
- Standard form of a quadratic function: :math:`f(x) = a\\cdot{x^2} + b\\cdot{x} + c`
- Quadratic formula: :math:`x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}`
- |quadratic_formula|
Examples
--------
Import `quadratic_roots` function from `regressions` library
>>> from regressions.analyses.roots.quadratic import quadratic_roots
Calculate the roots of a quadratic function with coefficients 2, 7, and 5
>>> roots_first = quadratic_roots(2, 7, 5)
>>> print(roots_first)
[-2.5, -1.0]
Calculate the roots of a quadratic function with coefficients 2, -5, and 3
>>> roots_second = quadratic_roots(2, -5, 3)
>>> print(roots_second)
[1.0, 1.5]
Calculate the roots of a quadratic function with all inputs set to 0
>>> roots_zeroes = quadratic_roots(0, 0, 0)
>>> print(roots_zeroes)
[None]
"""
# Handle input errors
three_scalars(first_constant, second_constant, third_constant)
positive_integer(precision)
coefficients = no_zeroes([first_constant, second_constant, third_constant],
precision)
# Create intermediary list and list to return
roots = []
result = []
# Create intermediary variable
discriminant = coefficients[1]**2 - 4 * coefficients[0] * coefficients[2]
# Create roots
first_root = (-1 * coefficients[1] +
discriminant**(1 / 2)) / (2 * coefficients[0])
second_root = (-1 * coefficients[1] -
discriminant**(1 / 2)) / (2 * coefficients[0])
# Eliminate duplicate roots
if first_root == second_root:
roots.append(first_root)
# Eliminate complex roots
else:
if not isinstance(first_root, complex):
roots.append(first_root)
if not isinstance(second_root, complex):
roots.append(second_root)
# Handle no roots
if not roots:
roots.append(None)
# Sort roots
sorted_roots = sorted_list(roots)
# Round roots
rounded_roots = rounded_list(sorted_roots, precision)
# Return result
result.extend(rounded_roots)
return result
def quadratic_integral(first_constant,
second_constant,
third_constant,
precision=4):
"""
Generates the integral of a quadratic function
Parameters
----------
first_constant : int or float
Coefficient of the quadratic term of the original quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
second_constant : int or float
Coefficient of the linear term of the original quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
third_constant : int or float
Coefficient of the constant term of the original quadratic function; if zero, it will be converted to a small, non-zero decimal value (e.g., 0.0001)
precision : int, default=4
Maximum number of digits that can appear after the decimal place of the resultant roots
Raises
------
TypeError
First three arguments must be integers or floats
ValueError
Last argument must be a positive integer
Returns
-------
integral['constants'] : list of float
Coefficients of the resultant integral
integral['evaluation'] : func
Function for evaluating the resultant integral at any float or integer argument
See Also
--------
:func:`~regressions.analyses.equations.quadratic.quadratic_equation`, :func:`~regressions.analyses.derivatives.quadratic.quadratic_derivatives`, :func:`~regressions.analyses.roots.quadratic.quadratic_roots`, :func:`~regressions.models.quadratic.quadratic_model`
Notes
-----
- Standard form of a quadratic function: :math:`f(x) = a\\cdot{x^2} + b\\cdot{x} + c`
- Integral of a quadratic function: :math:`F(x) = \\frac{a}{3}\\cdot{x^3} + \\frac{b}{2}\\cdot{x^2} + c\\cdot{x}`
- |indefinite_integral|
- |integration_formulas|
Examples
--------
Import `quadratic_integral` function from `regressions` library
>>> from regressions.analyses.integrals.quadratic import quadratic_integral
Generate the integral of a quadratic function with coefficients 2, 3, and 5, then display its coefficients
>>> integral_constants = quadratic_integral(2, 3, 5)
>>> print(integral_constants['constants'])
[0.6667, 1.5, 5.0]
Generate the integral of a quadratic function with coefficients 7, -5, and 3, then evaluate its integral at 10
>>> integral_evaluation = quadratic_integral(7, -5, 3)
>>> print(integral_evaluation['evaluation'](10))
2113.3
Generate the integral of a quadratic function with all inputs set to 0, then display its coefficients
>>> integral_zeroes = quadratic_integral(0, 0, 0)
>>> print(integral_zeroes['constants'])
[0.0001, 0.0001, 0.0001]
"""
# Handle input errors
three_scalars(first_constant, second_constant, third_constant)
positive_integer(precision)
coefficients = no_zeroes([first_constant, second_constant, third_constant],
precision)
# Create constants
integral_coefficients = [(1 / 3) * coefficients[0],
(1 / 2) * coefficients[1], coefficients[2]]
constants = rounded_list(integral_coefficients, precision)
# Create evaluation
def quadratic_evaluation(variable):
evaluation = constants[0] * variable**3 + constants[
1] * variable**2 + constants[2] * variable
rounded_evaluation = rounded_value(evaluation, precision)
return rounded_evaluation
# Package constants and evaluation in single dictionary
results = {'constants': constants, 'evaluation': quadratic_evaluation}
return results