tessl/pypi-scipp
Multi-dimensional data arrays with labeled dimensions for scientific computing
—
Pending
mathematical-operations.mddocs/
Mathematical Operations
Comprehensive mathematical functions including arithmetic, trigonometric, logarithmic, and specialized operations with automatic unit propagation, uncertainty handling, and element-wise computation. All operations preserve dimensional labels and propagate units according to physical laws.
Capabilities
Arithmetic Operations
Basic arithmetic operations with automatic unit propagation and uncertainty handling.
def add(x, y):
"""
Element-wise addition with unit checking
Args:
x (Variable or DataArray): First operand
y (Variable or DataArray): Second operand
Returns:
Variable or DataArray: Element-wise sum
Raises:
UnitError: If units are incompatible
"""
def subtract(x, y):
"""
Element-wise subtraction with unit checking
Args:
x (Variable or DataArray): First operand
y (Variable or DataArray): Second operand
Returns:
Variable or DataArray: Element-wise difference
Raises:
UnitError: If units are incompatible
"""
def multiply(x, y):
"""
Element-wise multiplication with unit multiplication
Args:
x (Variable or DataArray): First operand
y (Variable or DataArray): Second operand
Returns:
Variable or DataArray: Element-wise product
"""
def divide(x, y):
"""
Element-wise division with unit division
Args:
x (Variable or DataArray): Dividend
y (Variable or DataArray): Divisor
Returns:
Variable or DataArray: Element-wise quotient
"""
def floor_divide(x, y):
"""
Element-wise floor division
Args:
x (Variable or DataArray): Dividend
y (Variable or DataArray): Divisor
Returns:
Variable or DataArray: Element-wise floor quotient
"""
def mod(x, y):
"""
Element-wise modulo operation
Args:
x (Variable or DataArray): Dividend
y (Variable or DataArray): Divisor
Returns:
Variable or DataArray: Element-wise remainder
"""
def negative(x):
"""
Element-wise negation
Args:
x (Variable or DataArray): Input
Returns:
Variable or DataArray: Element-wise negation
"""Power and Root Functions
Exponential and root operations with proper unit handling.
def pow(x, y):
"""
Element-wise power operation
Args:
x (Variable or DataArray): Base
y (Variable or DataArray): Exponent (must be dimensionless)
Returns:
Variable or DataArray: x raised to power y
Raises:
UnitError: If exponent has units
"""
def sqrt(x):
"""
Element-wise square root
Args:
x (Variable or DataArray): Input
Returns:
Variable or DataArray: Element-wise square root
"""
def reciprocal(x):
"""
Element-wise reciprocal (1/x)
Args:
x (Variable or DataArray): Input
Returns:
Variable or DataArray: Element-wise reciprocal
"""Exponential and Logarithmic Functions
Exponential and logarithmic operations requiring dimensionless inputs.
def exp(x):
"""
Element-wise exponential function
Args:
x (Variable or DataArray): Input (must be dimensionless)
Returns:
Variable or DataArray: e^x
Raises:
UnitError: If input has units
"""
def log(x):
"""
Element-wise natural logarithm
Args:
x (Variable or DataArray): Input (must be dimensionless and positive)
Returns:
Variable or DataArray: ln(x)
Raises:
UnitError: If input has units
"""
def log10(x):
"""
Element-wise base-10 logarithm
Args:
x (Variable or DataArray): Input (must be dimensionless and positive)
Returns:
Variable or DataArray: log10(x)
Raises:
UnitError: If input has units
"""Rounding Functions
Functions for rounding and truncating values.
def round(x, decimals=0):
"""
Element-wise rounding
Args:
x (Variable or DataArray): Input
decimals (int): Number of decimal places
Returns:
Variable or DataArray: Rounded values
"""
def floor(x):
"""
Element-wise floor operation
Args:
x (Variable or DataArray): Input
Returns:
Variable or DataArray: Floor values
"""
def ceil(x):
"""
Element-wise ceiling operation
Args:
x (Variable or DataArray): Input
Returns:
Variable or DataArray: Ceiling values
"""Trigonometric Functions
Trigonometric functions with proper angle unit handling.
def sin(x):
"""
Element-wise sine
Args:
x (Variable or DataArray): Angle (rad or deg units)
Returns:
Variable or DataArray: sin(x) (dimensionless)
Raises:
UnitError: If input is not an angle
"""
def cos(x):
"""
Element-wise cosine
Args:
x (Variable or DataArray): Angle (rad or deg units)
Returns:
Variable or DataArray: cos(x) (dimensionless)
Raises:
UnitError: If input is not an angle
"""
def tan(x):
"""
Element-wise tangent
Args:
x (Variable or DataArray): Angle (rad or deg units)
Returns:
Variable or DataArray: tan(x) (dimensionless)
Raises:
UnitError: If input is not an angle
"""
def asin(x):
"""
Element-wise arcsine
Args:
x (Variable or DataArray): Input (dimensionless, [-1, 1])
Returns:
Variable or DataArray: arcsin(x) in radians
Raises:
UnitError: If input has units
"""
def acos(x):
"""
Element-wise arccosine
Args:
x (Variable or DataArray): Input (dimensionless, [-1, 1])
Returns:
Variable or DataArray: arccos(x) in radians
Raises:
UnitError: If input has units
"""
def atan(x):
"""
Element-wise arctangent
Args:
x (Variable or DataArray): Input (dimensionless)
Returns:
Variable or DataArray: arctan(x) in radians
Raises:
UnitError: If input has units
"""
def atan2(y, x):
"""
Element-wise two-argument arctangent
Args:
y (Variable or DataArray): Y coordinates
x (Variable or DataArray): X coordinates (same units as y)
Returns:
Variable or DataArray: atan2(y, x) in radians
Raises:
UnitError: If x and y have different units
"""Hyperbolic Functions
Hyperbolic trigonometric functions for dimensionless inputs.
def sinh(x):
"""
Element-wise hyperbolic sine
Args:
x (Variable or DataArray): Input (dimensionless)
Returns:
Variable or DataArray: sinh(x)
Raises:
UnitError: If input has units
"""
def cosh(x):
"""
Element-wise hyperbolic cosine
Args:
x (Variable or DataArray): Input (dimensionless)
Returns:
Variable or DataArray: cosh(x)
Raises:
UnitError: If input has units
"""
def tanh(x):
"""
Element-wise hyperbolic tangent
Args:
x (Variable or DataArray): Input (dimensionless)
Returns:
Variable or DataArray: tanh(x)
Raises:
UnitError: If input has units
"""
def asinh(x):
"""
Element-wise inverse hyperbolic sine
Args:
x (Variable or DataArray): Input (dimensionless)
Returns:
Variable or DataArray: asinh(x)
Raises:
UnitError: If input has units
"""
def acosh(x):
"""
Element-wise inverse hyperbolic cosine
Args:
x (Variable or DataArray): Input (dimensionless, >= 1)
Returns:
Variable or DataArray: acosh(x)
Raises:
UnitError: If input has units
"""
def atanh(x):
"""
Element-wise inverse hyperbolic tangent
Args:
x (Variable or DataArray): Input (dimensionless, (-1, 1))
Returns:
Variable or DataArray: atanh(x)
Raises:
UnitError: If input has units
"""Special Mathematical Functions
Specialized mathematical functions for scientific computing.
def abs(x):
"""
Element-wise absolute value
Args:
x (Variable or DataArray): Input
Returns:
Variable or DataArray: |x|
"""
def erf(x):
"""
Element-wise error function
Args:
x (Variable or DataArray): Input (dimensionless)
Returns:
Variable or DataArray: erf(x)
Raises:
UnitError: If input has units
"""
def erfc(x):
"""
Element-wise complementary error function
Args:
x (Variable or DataArray): Input (dimensionless)
Returns:
Variable or DataArray: erfc(x) = 1 - erf(x)
Raises:
UnitError: If input has units
"""
def nan_to_num(x, *, nan=0.0, posinf=None, neginf=None):
"""
Replace NaN and infinity with finite numbers
Args:
x (Variable or DataArray): Input
nan: Value to replace NaN with
posinf: Value to replace positive infinity with
neginf: Value to replace negative infinity with
Returns:
Variable or DataArray: Array with finite values
"""Vector Operations
Operations specific to vector data types and multi-dimensional analysis.
def dot(x, y):
"""
Dot product of vectors
Args:
x (Variable or DataArray): First vector
y (Variable or DataArray): Second vector
Returns:
Variable or DataArray: Dot product
"""
def cross(x, y):
"""
Cross product of 3D vectors
Args:
x (Variable or DataArray): First 3D vector
y (Variable or DataArray): Second 3D vector
Returns:
Variable or DataArray: Cross product (3D vector)
"""
def norm(x):
"""
L2 norm of vectors
Args:
x (Variable or DataArray): Vector data
Returns:
Variable or DataArray: L2 norm
"""
def midpoints(x, dim):
"""
Calculate midpoints between adjacent elements
Args:
x (Variable or DataArray): Input array
dim (str): Dimension along which to calculate midpoints
Returns:
Variable or DataArray: Midpoint values
"""Usage Examples
Basic Arithmetic with Units
import scipp as sc
# Create physical quantities
distance = sc.array(dims=['x'], values=[1, 2, 3], unit='m')
time = sc.array(dims=['x'], values=[0.5, 1.0, 1.5], unit='s')
# Calculate velocity (units automatically computed)
velocity = distance / time # Result has unit 'm/s'
# Add compatible quantities
total_distance = distance + sc.array(dims=['x'], values=[0.5, 0.5, 0.5], unit='m')
# Multiply by dimensionless factor
doubled = distance * 2 # Units preservedMathematical Functions with Uncertainty Propagation
import numpy as np
# Create data with uncertainties
angles = sc.array(
dims=['angle'],
values=np.linspace(0, np.pi, 10),
variances=np.full(10, 0.01), # Small uncertainties
unit='rad'
)
# Apply trigonometric functions (uncertainties propagated automatically)
sin_values = sc.sin(angles) # Dimensionless result
cos_values = sc.cos(angles) # Dimensionless result
# Combine with arithmetic
amplitude = sc.scalar(2.5, variance=0.01, unit='V')
signal = amplitude * sin_values # Result in volts with propagated uncertaintyVector Operations
# Create 3D vectors
vec1 = sc.vectors(dims=['point'], values=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], unit='m')
vec2 = sc.vectors(dims=['point'], values=[[1, 1, 0], [1, 0, 1], [0, 1, 1]], unit='m')
# Vector operations
dot_products = sc.dot(vec1, vec2) # Dot product in m^2
cross_products = sc.cross(vec1, vec2) # Cross product in m^2
magnitudes = sc.norm(vec1) # Vector magnitudes in mLogarithmic and Exponential Operations
# Create dimensionless data for logarithmic functions
ratios = sc.array(dims=['measurement'], values=[0.1, 1.0, 10.0])
# Apply logarithmic functions
ln_ratios = sc.log(ratios) # Natural logarithm
log10_ratios = sc.log10(ratios) # Base-10 logarithm
# Exponential operations
exp_values = sc.exp(ln_ratios) # Should recover original ratios
# Power operations with proper unit handling
squared = sc.pow(distance, 2) # Result in m^2Complex Mathematical Workflows
# Scientific data processing workflow
raw_signal = sc.array(
dims=['time'],
values=np.sin(np.linspace(0, 4*np.pi, 100)) + 0.1*np.random.random(100),
unit='V'
)
# Apply mathematical transformations
normalized = raw_signal / sc.max(sc.abs(raw_signal)) # Normalize to [-1, 1]
squared = sc.pow(normalized, 2) # Square the signal
smoothed = sc.sqrt(squared) # Smooth via absolute value
# Phase analysis
time_coord = sc.linspace('time', 0, 4*np.pi, 100, unit='s')
phase = sc.atan2(raw_signal, sc.cos(time_coord)) # Calculate phaseInstall with Tessl CLI
npx tessl i tessl/pypi-scipp