Skip to content

gradient_aware_harmonisation.spline#

Spline handling

Classes:

Name Description
Spline

Single spline
SplineScipy

An adapter which wraps various classes from scipy.interpolate
SumOfSplines

Sum of two splines

Functions:

Name Description
add_constant_to_spline

Add a constant value to a spline

Attributes:

Name Type Description
NP_ARRAY_OF_FLOAT_OR_INT TypeAlias

Type alias for an array of numpy float or int (not complex)
NP_FLOAT_OR_INT TypeAlias

Type alias for a numpy float or int (not complex)

NP_ARRAY_OF_FLOAT_OR_INT module-attribute #

NP_ARRAY_OF_FLOAT_OR_INT: TypeAlias = NDArray[
    NP_FLOAT_OR_INT
]

Type alias for an array of numpy float or int (not complex)

NP_FLOAT_OR_INT module-attribute #

NP_FLOAT_OR_INT: TypeAlias = Union[
    floating[Any], integer[Any]
]

Type alias for a numpy float or int (not complex)

Spline #

Bases: Protocol

Single spline

Methods:

Name Description
__call__

Get the value of the spline at a particular x-value
antiderivative

Calculate the anti-derivative/integral of self
derivative

Calculate the derivative of self
Source code in src/gradient_aware_harmonisation/spline.py 
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
class Spline(Protocol):
    """
    Single spline
    """

    # domain: [float, float]
    # """Domain over the spline can be used"""

    @overload
    def __call__(self, x: int | float) -> int | float: ...

    @overload
    def __call__(self, x: NP_FLOAT_OR_INT) -> NP_FLOAT_OR_INT: ...

    @overload
    def __call__(self, x: NP_ARRAY_OF_FLOAT_OR_INT) -> NP_ARRAY_OF_FLOAT_OR_INT: ...

    def __call__(
        self, x: int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT
    ) -> int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT:
        """Get the value of the spline at a particular x-value"""

    def derivative(self) -> Spline:
        """
        Calculate the derivative of self
        """

    def antiderivative(self) -> Spline:
        """
        Calculate the anti-derivative/integral of self
        """

__call__ #

__call__(x: int | float) -> int | float

__call__(x: NP_FLOAT_OR_INT) -> NP_FLOAT_OR_INT

__call__(
    x: NP_ARRAY_OF_FLOAT_OR_INT,
) -> NP_ARRAY_OF_FLOAT_OR_INT

__call__(
    x: int
    | float
    | NP_FLOAT_OR_INT
    | NP_ARRAY_OF_FLOAT_OR_INT,
) -> (
    int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT
)

Get the value of the spline at a particular x-value

Source code in src/gradient_aware_harmonisation/spline.py 
47
48
49
50
def __call__(
    self, x: int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT
) -> int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT:
    """Get the value of the spline at a particular x-value"""

antiderivative #

antiderivative() -> Spline

Calculate the anti-derivative/integral of self

Source code in src/gradient_aware_harmonisation/spline.py 
57
58
59
60
def antiderivative(self) -> Spline:
    """
    Calculate the anti-derivative/integral of self
    """

derivative #

derivative() -> Spline

Calculate the derivative of self

Source code in src/gradient_aware_harmonisation/spline.py 
52
53
54
55
def derivative(self) -> Spline:
    """
    Calculate the derivative of self
    """

SplineScipy #

An adapter which wraps various classes from scipy.interpolate

Methods:

Name Description
__call__

Evaluate the spline at a given x-value
antiderivative

Calculate the anti-derivative/integral of self
derivative

Calculate the derivative of self
Source code in src/gradient_aware_harmonisation/spline.py 
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
@define
class SplineScipy:
    """
    An adapter which wraps various classes from [scipy.interpolate][]
    """

    # domain: ClassVar[list[float, float]] = [
    #     np.finfo(np.float64).tiny,
    #     np.finfo(np.float64).max,
    # ]
    # """domain of spline (reals)"""

    scipy_spline: scipy.interpolate.BSpline | scipy.interpolate.PPoly

    @overload
    def __call__(self, x: int | float) -> int | float: ...

    @overload
    def __call__(self, x: NP_FLOAT_OR_INT) -> NP_FLOAT_OR_INT: ...

    @overload
    def __call__(self, x: NP_ARRAY_OF_FLOAT_OR_INT) -> NP_ARRAY_OF_FLOAT_OR_INT: ...

    def __call__(
        self, x: int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT
    ) -> int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT:
        """
        Evaluate the spline at a given x-value

        Parameters
        ----------
        x
            x-value

        Returns
        -------
        :
            Value of the spline at `x`
        """
        return self.scipy_spline(x)

    def derivative(self) -> SplineScipy:
        """
        Calculate the derivative of self

        Returns
        -------
        :
            Derivative of self
        """
        return SplineScipy(self.scipy_spline.derivative())

    def antiderivative(self) -> SplineScipy:
        """
        Calculate the anti-derivative/integral of self

        Returns
        -------
        :
            Anti-derivative of self
        """
        return SplineScipy(self.scipy_spline.antiderivative())

__call__ #

__call__(x: int | float) -> int | float

__call__(x: NP_FLOAT_OR_INT) -> NP_FLOAT_OR_INT

__call__(
    x: NP_ARRAY_OF_FLOAT_OR_INT,
) -> NP_ARRAY_OF_FLOAT_OR_INT

__call__(
    x: int
    | float
    | NP_FLOAT_OR_INT
    | NP_ARRAY_OF_FLOAT_OR_INT,
) -> (
    int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT
)

Evaluate the spline at a given x-value

Parameters:

Name Type Description Default
x int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT

x-value

 required

Returns:

Type Description
int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT

Value of the spline at x
Source code in src/gradient_aware_harmonisation/spline.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
def __call__(
    self, x: int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT
) -> int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT:
    """
    Evaluate the spline at a given x-value

    Parameters
    ----------
    x
        x-value

    Returns
    -------
    :
        Value of the spline at `x`
    """
    return self.scipy_spline(x)

antiderivative #

antiderivative() -> SplineScipy

Calculate the anti-derivative/integral of self

Returns:

Type Description
SplineScipy

Anti-derivative of self
Source code in src/gradient_aware_harmonisation/spline.py 
115
116
117
118
119
120
121
122
123
124
def antiderivative(self) -> SplineScipy:
    """
    Calculate the anti-derivative/integral of self

    Returns
    -------
    :
        Anti-derivative of self
    """
    return SplineScipy(self.scipy_spline.antiderivative())

derivative #

derivative() -> SplineScipy

Calculate the derivative of self

Returns:

Type Description
SplineScipy

Derivative of self
Source code in src/gradient_aware_harmonisation/spline.py 
104
105
106
107
108
109
110
111
112
113
def derivative(self) -> SplineScipy:
    """
    Calculate the derivative of self

    Returns
    -------
    :
        Derivative of self
    """
    return SplineScipy(self.scipy_spline.derivative())

SumOfSplines #

Sum of two splines

Methods:

Name Description
__call__

Evaluate the spline at a given x-value
antiderivative

Calculate the anti-derivative/integral of self
derivative

Calculate the derivative of self

Attributes:

Name Type Description
spline_one Spline

First spline
spline_two Spline

Second spline
Source code in src/gradient_aware_harmonisation/spline.py 
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
@define
class SumOfSplines:
    """
    Sum of two splines
    """

    spline_one: Spline
    """First spline"""

    spline_two: Spline
    """Second spline"""

    # domain: ClassVar[list[float, float]] = [
    #     np.finfo(np.float64).tiny,
    #     np.finfo(np.float64).max,
    # ]
    # """Domain of spline"""

    @overload
    def __call__(self, x: int | float) -> int | float: ...

    @overload
    def __call__(self, x: NP_FLOAT_OR_INT) -> NP_FLOAT_OR_INT: ...

    @overload
    def __call__(self, x: NP_ARRAY_OF_FLOAT_OR_INT) -> NP_ARRAY_OF_FLOAT_OR_INT: ...

    def __call__(
        self, x: int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT
    ) -> int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT:
        """
        Evaluate the spline at a given x-value

        Parameters
        ----------
        x
            x-value

        Returns
        -------
        :
            Value of the spline at `x`
        """
        return self.spline_one(x) + self.spline_two(x)

    def derivative(self) -> SumOfSplines:
        """
        Calculate the derivative of self

        Returns
        -------
        :
            Derivative of self
        """
        return SumOfSplines(self.spline_one.derivative(), self.spline_two.derivative())

    def antiderivative(self) -> SumOfSplines:
        """
        Calculate the anti-derivative/integral of self

        Returns
        -------
        :
            Anti-derivative of self
        """
        return SumOfSplines(
            self.spline_one.antiderivative(), self.spline_two.antiderivative()
        )

spline_one instance-attribute #

spline_one: Spline

First spline

spline_two instance-attribute #

spline_two: Spline

Second spline

__call__ #

__call__(x: int | float) -> int | float

__call__(x: NP_FLOAT_OR_INT) -> NP_FLOAT_OR_INT

__call__(
    x: NP_ARRAY_OF_FLOAT_OR_INT,
) -> NP_ARRAY_OF_FLOAT_OR_INT

__call__(
    x: int
    | float
    | NP_FLOAT_OR_INT
    | NP_ARRAY_OF_FLOAT_OR_INT,
) -> (
    int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT
)

Evaluate the spline at a given x-value

Parameters:

Name Type Description Default
x int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT

x-value

 required

Returns:

Type Description
int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT

Value of the spline at x
Source code in src/gradient_aware_harmonisation/spline.py 
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
def __call__(
    self, x: int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT
) -> int | float | NP_FLOAT_OR_INT | NP_ARRAY_OF_FLOAT_OR_INT:
    """
    Evaluate the spline at a given x-value

    Parameters
    ----------
    x
        x-value

    Returns
    -------
    :
        Value of the spline at `x`
    """
    return self.spline_one(x) + self.spline_two(x)

antiderivative #

antiderivative() -> SumOfSplines

Calculate the anti-derivative/integral of self

Returns:

Type Description
SumOfSplines

Anti-derivative of self
Source code in src/gradient_aware_harmonisation/spline.py 
183
184
185
186
187
188
189
190
191
192
193
194
def antiderivative(self) -> SumOfSplines:
    """
    Calculate the anti-derivative/integral of self

    Returns
    -------
    :
        Anti-derivative of self
    """
    return SumOfSplines(
        self.spline_one.antiderivative(), self.spline_two.antiderivative()
    )

derivative #

derivative() -> SumOfSplines

Calculate the derivative of self

Returns:

Type Description
SumOfSplines

Derivative of self
Source code in src/gradient_aware_harmonisation/spline.py 
172
173
174
175
176
177
178
179
180
181
def derivative(self) -> SumOfSplines:
    """
    Calculate the derivative of self

    Returns
    -------
    :
        Derivative of self
    """
    return SumOfSplines(self.spline_one.derivative(), self.spline_two.derivative())

add_constant_to_spline #

add_constant_to_spline(
    in_spline: Spline, constant: float | int
) -> Spline

Add a constant value to a spline

Parameters:

Name Type Description Default
in_spline Spline

Input spline

 required
constant float | int

Constant to add

 required

Returns:

Type Description
Spline

Spline plus the given constant
Source code in src/gradient_aware_harmonisation/spline.py 
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
def add_constant_to_spline(in_spline: Spline, constant: float | int) -> Spline:
    """
    Add a constant value to a spline

    Parameters
    ----------
    in_spline
        Input spline

    constant
        Constant to add

    Returns
    -------
    :
        Spline plus the given constant
    """
    try:
        import scipy.interpolate
    except ImportError as exc:
        raise MissingOptionalDependencyError(
            "add_constant_to_spline", requirement="scipy"
        ) from exc

    return SumOfSplines(
        spline_one=in_spline,
        spline_two=SplineScipy(
            scipy.interpolate.PPoly(
                c=[[constant]],
                # # TODO: Problem: Currently domain is defined for SumOfSplines
                # #  and SplineScipy should be specified only once
                # #  preferably in SplineScipy
                # x=in_spline.domain,
                # TODO: better solution for domain handling
                x=[-1e8, 1e8],
            )
        ),
    )