def __init__(self, variable):
"""Represents the absolute value squared of a variable
Parameters
----------
variable : str
Name of variable.
"""
assert_str(variable)
self._variable = variable
def __init__(self, scalar, variable):
assert_is_scalar(scalar)
assert_str(variable)
if not isinstance(scalar, ProductOfScalars):
raise TypeError(
f"scalar should be ProductOfScalars, not {type(scalar)}")
if not all(has_variable(factor, variable) for factor in scalar):
raise ValueError("all factors should have the integration term")
self._scalar = scalar
self._variable = variable
def __init__(self, func_name1, func_name2):
"""Represents the inner product of two functions.
Parameters
----------
func_name1 : str
Name of first function
func_name2 : str
Name of second function
"""
assert_str(func_name1)
assert_str(func_name2)
self._func_names = sorted([func_name1, func_name2])
def __init__(self, variable, conjugate=False):
"""Represents a number as a variable
Parameters
----------
variable : str
Name of variable.
conjugate (optional) : bool
If the variable is conjugated (default: `False`)
"""
assert_str(variable)
self._variable = variable
self._conjugate = conjugate
def __init__(self, var1, var2):
"""Delta function between two variables, e.g. d(x - y)
Parameters
----------
var1 : str
First variable
var2 : str
First variable
"""
assert_str(var1)
assert_str(var2)
self._assert_different(var1, var2)
self._vars = [var1, var2]
def __init__(self, func_name, variable, conjugate=False):
"""Represents a function with a single symbolic variable, e.g. f(x).
Parameters
----------
func_name : str
Name of function.
variable : str
Name of variable.
conjugate (optional) : bool
If the functions is conjugated (default: `False`)
"""
assert_str(func_name)
assert_str(variable)
self._func_name = func_name
self._variable = variable
self._conjugate = conjugate
def __init__(self, mode, variable, creation=True):
"""
Represents an creation/annihilation operator in a given mode with a given variable
representing for example the frequency of the excitation.
Parameters
----------
mode: str
The mode of the excitation
variable: str
The variable describing the continous variable
creation : bool
Whether this is a creation operator or not (annihilation).
"""
assert_str(mode)
assert_str(variable)
self._mode = mode
self._variable = variable
self._creation = creation
def integrate(scalar, variable=None):
"""
Integrates a scalar over a given variable or variables.
Parameters
----------
scalar : :class:`~.scalar.Scalar`
The scalar to integrate.
variable : None or str or set of str
The variable(s) to integrate over.
Can be:
* `None`: Then all variables in the scalar are integrated out.
* `str`: Then a single variable is integrated out.
* `set` of `str`: Then all the variables in the set are integrated out.
Returns
-------
:class:`~.scalar.Scalar`
The output of the integration.
"""
# TODO needed?
scalar = simplify(scalar)
if variable is None:
return integrate(scalar, get_variables(scalar))
if isinstance(variable, set):
new_scalar = scalar
for v in variable:
new_scalar = integrate(new_scalar, v)
return new_scalar
assert_str(variable)
if isinstance(scalar, SumOfScalars):
new_scalar = sum(integrate(s, variable) for s in scalar._terms)
# elif isinstance(scalar, ProductOfScalars):
elif isinstance(scalar, Scalar):
if isinstance(scalar, ProductOfScalars):
factors = scalar._factors
else:
factors = [scalar]
# Split factors based on if they contain the integration variable or not
var_factors = []
other_factors = []
for factor in factors:
if isinstance(factor, Scalar) and has_variable(factor, variable):
var_factors.append(factor)
else:
other_factors.append(factor)
if len(var_factors) > 0:
integration_part = [
_Integration(ProductOfScalars(var_factors), variable)
]
else:
integration_part = []
new_scalar = ProductOfScalars(other_factors + integration_part)
elif is_number(scalar):
new_scalar = scalar
else:
raise NotImplementedError(
f"integrate not implemented for type {type(scalar)}")
return simplify(new_scalar)