colour.continuous.MultiSignals#

class colour.continuous.MultiSignals(data: ArrayLike | DataFrame | dict | Self | Sequence | Series | Signal | None = None, domain: ArrayLike | None = None, labels: Sequence | None = None, **kwargs: Any)[source]#

Bases: AbstractContinuousFunction

Define the base class for multi-continuous signals, a container for multiple colour.continuous.Signal sub-class instances.

Important

Specific documentation about getting, setting, indexing and slicing the multi-continuous signals values is available in the Spectral Representation and Continuous Signal section.

Parameters:

Attributes

Methods

Examples

Instantiation with implicit domain and a single signal:

>>> range_ = np.linspace(10, 100, 10)
>>> print(MultiSignals(range_))
[[   0.   10.]
 [   1.   20.]
 [   2.   30.]
 [   3.   40.]
 [   4.   50.]
 [   5.   60.]
 [   6.   70.]
 [   7.   80.]
 [   8.   90.]
 [   9.  100.]]

Instantiation with explicit domain and a single signal:

>>> domain = np.arange(100, 1100, 100)
>>> print(MultiSignals(range_, domain))
[[  100.    10.]
 [  200.    20.]
 [  300.    30.]
 [  400.    40.]
 [  500.    50.]
 [  600.    60.]
 [  700.    70.]
 [  800.    80.]
 [  900.    90.]
 [ 1000.   100.]]

Instantiation with multiple signals:

>>> range_ = tstack([np.linspace(10, 100, 10)] * 3)
>>> range_ += np.array([0, 10, 20])
>>> print(MultiSignals(range_, domain))
[[  100.    10.    20.    30.]
 [  200.    20.    30.    40.]
 [  300.    30.    40.    50.]
 [  400.    40.    50.    60.]
 [  500.    50.    60.    70.]
 [  600.    60.    70.    80.]
 [  700.    70.    80.    90.]
 [  800.    80.    90.   100.]
 [  900.    90.   100.   110.]
 [ 1000.   100.   110.   120.]]

Instantiation with a dict:

>>> print(MultiSignals(dict(zip(domain, range_))))
[[  100.    10.    20.    30.]
 [  200.    20.    30.    40.]
 [  300.    30.    40.    50.]
 [  400.    40.    50.    60.]
 [  500.    50.    60.    70.]
 [  600.    60.    70.    80.]
 [  700.    70.    80.    90.]
 [  800.    80.    90.   100.]
 [  900.    90.   100.   110.]
 [ 1000.   100.   110.   120.]]

Instantiation using a Signal sub-class:

>>> class NotSignal(Signal):
...     pass
>>> multi_signals = MultiSignals(range_, domain, signal_type=NotSignal)
>>> print(multi_signals)
[[  100.    10.    20.    30.]
 [  200.    20.    30.    40.]
 [  300.    30.    40.    50.]
 [  400.    40.    50.    60.]
 [  500.    50.    60.    70.]
 [  600.    60.    70.    80.]
 [  700.    70.    80.    90.]
 [  800.    80.    90.   100.]
 [  900.    90.   100.   110.]
 [ 1000.   100.   110.   120.]]
 >>> type(multi_signals.signals[0])  
 <class 'multi_signals.NotSignal'>

Instantiation with a Pandas Series:

>>> if is_pandas_installed():
...     from pandas import Series
...
...     print(
...         MultiSignals(  
...             Series(dict(zip(domain, np.linspace(10, 100, 10))))
...         )
...     )
[[  100.    10.]
 [  200.    20.]
 [  300.    30.]
 [  400.    40.]
 [  500.    50.]
 [  600.    60.]
 [  700.    70.]
 [  800.    80.]
 [  900.    90.]
 [ 1000.   100.]]

Instantiation with a Pandas pandas.DataFrame:

>>> if is_pandas_installed():
...     from pandas import DataFrame
...
...     data = dict(zip(["a", "b", "c"], tsplit(range_)))
...     print(MultiSignals(DataFrame(data, domain)))  
[[  100.    10.    20.    30.]
 [  200.    20.    30.    40.]
 [  300.    30.    40.    50.]
 [  400.    40.    50.    60.]
 [  500.    50.    60.    70.]
 [  600.    60.    70.    80.]
 [  700.    70.    80.    90.]
 [  800.    80.    90.   100.]
 [  900.    90.   100.   110.]
 [ 1000.   100.   110.   120.]]

Retrieving domain y variable for arbitrary range x variable:

>>> x = 150
>>> range_ = tstack([np.sin(np.linspace(0, 1, 10))] * 3)
>>> range_ += np.array([0.0, 0.25, 0.5])
>>> MultiSignals(range_, domain)[x]  
array([ 0.0359701...,  0.2845447...,  0.5331193...])
>>> x = np.linspace(100, 1000, 3)
>>> MultiSignals(range_, domain)[x]  
array([[  4.4085384...e-20,   2.5000000...e-01,   5.0000000...e-01],
       [  4.7669395...e-01,   7.2526859...e-01,   9.7384323...e-01],
       [  8.4147098...e-01,   1.0914709...e+00,   1.3414709...e+00]])

Using an alternative interpolating function:

>>> x = 150
>>> from colour.algebra import CubicSplineInterpolator
>>> MultiSignals(range_, domain, interpolator=CubicSplineInterpolator)[
...     x
... ]  
array([ 0.0555274...,  0.3055274...,  0.5555274...])
>>> x = np.linspace(100, 1000, 3)
>>> MultiSignals(range_, domain, interpolator=CubicSplineInterpolator)[
...     x
... ]  
array([[ 0.       ...,  0.25     ...,  0.5      ...],
       [ 0.4794253...,  0.7294253...,  0.9794253...],
       [ 0.8414709...,  1.0914709...,  1.3414709...]])
__init__(data: ArrayLike | DataFrame | dict | Self | Sequence | Series | Signal | None = None, domain: ArrayLike | None = None, labels: Sequence | None = None, **kwargs: Any) None[source]#
Parameters:
  • data (ArrayLike | DataFrame | dict | Self | Sequence | Series | Signal | None) –

  • domain (ArrayLike | None) –

  • labels (Sequence | None) –

  • kwargs (Any) –

Return type:

None

property dtype: Type[DTypeFloat]#

Getter and setter property for the continuous signal dtype.

Parameters:

value – Value to set the continuous signal dtype with.

Returns:

Continuous signal dtype.

Return type:

Type[DTypeFloat]

property domain: NDArrayFloat#

Getter and setter property for the colour.continuous.Signal sub-class instances independent domain variable \(x\).

Parameters:

value – Value to set the colour.continuous.Signal sub-class instances independent domain variable \(x\) with.

Returns:

colour.continuous.Signal sub-class instances independent domain variable \(x\).

Return type:

numpy.ndarray

property range: NDArrayFloat#

Getter and setter property for the colour.continuous.Signal sub-class instances corresponding range variable \(y\).

Parameters:

value – Value to set the colour.continuous.Signal sub-class instances corresponding range variable \(y\) with.

Returns:

colour.continuous.Signal sub-class instances corresponding range variable \(y\).

Return type:

numpy.ndarray

property interpolator: Type[ProtocolInterpolator]#

Getter and setter property for the colour.continuous.Signal sub-class instances interpolator type.

Parameters:

value – Value to set the colour.continuous.Signal sub-class instances interpolator type with.

Returns:

colour.continuous.Signal sub-class instances interpolator type.

Return type:

Type[ProtocolInterpolator]

property interpolator_kwargs: dict#

Getter and setter property for the colour.continuous.Signal sub-class instances interpolator instantiation time arguments.

Parameters:

value – Value to set the colour.continuous.Signal sub-class instances interpolator instantiation time arguments to.

Returns:

colour.continuous.Signal sub-class instances interpolator instantiation time arguments.

Return type:

dict

property extrapolator: Type[ProtocolExtrapolator]#

Getter and setter property for the colour.continuous.Signal sub-class instances extrapolator type.

Parameters:

value – Value to set the colour.continuous.Signal sub-class instances extrapolator type with.

Returns:

colour.continuous.Signal sub-class instances extrapolator type.

Return type:

Type[ProtocolExtrapolator]

property extrapolator_kwargs: dict#

Getter and setter property for the colour.continuous.Signal sub-class instances extrapolator instantiation time arguments.

Parameters:

value – Value to set the colour.continuous.Signal sub-class instances extrapolator instantiation time arguments to.

Returns:

colour.continuous.Signal sub-class instances extrapolator instantiation time arguments.

Return type:

dict

property function: Callable#

Getter property for the colour.continuous.Signal sub-class instances callable.

Returns:

colour.continuous.Signal sub-class instances callable.

Return type:

Callable

property signals: Dict[str, Signal]#

Getter and setter property for the colour.continuous.Signal sub-class instances.

Parameters:

value – Attribute value.

Returns:

colour.continuous.Signal sub-class instances.

Return type:

dict

property labels: List[str]#

Getter and setter property for the colour.continuous.Signal sub-class instance names.

Parameters:

value – Value to set the colour.continuous.Signal sub-class instance names.

Returns:

colour.continuous.Signal sub-class instance names.

Return type:

list

property signal_type: Type[Signal]#

Getter property for the colour.continuous.Signal sub-class instances type.

Returns:

colour.continuous.Signal sub-class instances type.

Return type:

Type[Signal]

__str__() str[source]#

Return a formatted string representation of the multi-continuous signals.

Returns:

Formatted string representation.

Return type:

str

Examples

>>> domain = np.arange(0, 10, 1)
>>> range_ = tstack([np.linspace(10, 100, 10)] * 3)
>>> range_ += np.array([0, 10, 20])
>>> print(MultiSignals(range_))
[[   0.   10.   20.   30.]
 [   1.   20.   30.   40.]
 [   2.   30.   40.   50.]
 [   3.   40.   50.   60.]
 [   4.   50.   60.   70.]
 [   5.   60.   70.   80.]
 [   6.   70.   80.   90.]
 [   7.   80.   90.  100.]
 [   8.   90.  100.  110.]
 [   9.  100.  110.  120.]]
__repr__() str[source]#

Return an evaluable string representation of the multi-continuous signals.

Returns:

Evaluable string representation.

Return type:

str

Examples

>>> domain = np.arange(0, 10, 1)
>>> range_ = tstack([np.linspace(10, 100, 10)] * 3)
>>> range_ += np.array([0, 10, 20])
>>> MultiSignals(range_)
MultiSignals([[   0.,   10.,   20.,   30.],
              [   1.,   20.,   30.,   40.],
              [   2.,   30.,   40.,   50.],
              [   3.,   40.,   50.,   60.],
              [   4.,   50.,   60.,   70.],
              [   5.,   60.,   70.,   80.],
              [   6.,   70.,   80.,   90.],
              [   7.,   80.,   90.,  100.],
              [   8.,   90.,  100.,  110.],
              [   9.,  100.,  110.,  120.]],
             ['0', '1', '2'],
             KernelInterpolator,
             {},
             Extrapolator,
             {'method': 'Constant', 'left': nan, 'right': nan})
__hash__() int[source]#

Return the abstract continuous function hash.

Returns:

Object hash.

Return type:

int

__getitem__(x: ArrayLike | slice) NDArrayFloat[source]#

Return the corresponding range variable \(y\) for independent domain variable \(x\).

Parameters:

x (ArrayLike | slice) – Independent domain variable \(x\).

Returns:

Variable \(y\) range value.

Return type:

numpy.ndarray

Examples

>>> range_ = tstack([np.linspace(10, 100, 10)] * 3)
>>> range_ += np.array([0, 10, 20])
>>> multi_signals = MultiSignals(range_)
>>> print(multi_signals)
[[   0.   10.   20.   30.]
 [   1.   20.   30.   40.]
 [   2.   30.   40.   50.]
 [   3.   40.   50.   60.]
 [   4.   50.   60.   70.]
 [   5.   60.   70.   80.]
 [   6.   70.   80.   90.]
 [   7.   80.   90.  100.]
 [   8.   90.  100.  110.]
 [   9.  100.  110.  120.]]
>>> multi_signals[0]
array([ 10.,  20.,  30.])
>>> multi_signals[np.array([0, 1, 2])]
array([[ 10.,  20.,  30.],
       [ 20.,  30.,  40.],
       [ 30.,  40.,  50.]])
>>> multi_signals[np.linspace(0, 5, 5)]  
array([[ 10.       ...,  20.       ...,  30.       ...],
       [ 22.8348902...,  32.8046056...,  42.774321 ...],
       [ 34.8004492...,  44.7434347...,  54.6864201...],
       [ 47.5535392...,  57.5232546...,  67.4929700...],
       [ 60.       ...,  70.       ...,  80.       ...]])
>>> multi_signals[0:3]
array([[ 10.,  20.,  30.],
       [ 20.,  30.,  40.],
       [ 30.,  40.,  50.]])
>>> multi_signals[:, 0:2]
array([[  10.,   20.],
       [  20.,   30.],
       [  30.,   40.],
       [  40.,   50.],
       [  50.,   60.],
       [  60.,   70.],
       [  70.,   80.],
       [  80.,   90.],
       [  90.,  100.],
       [ 100.,  110.]])
__setitem__(x: ArrayLike | slice, y: ArrayLike)[source]#

Set the corresponding range variable \(y\) for independent domain variable \(x\).

Parameters:
  • x (ArrayLike | slice) – Independent domain variable \(x\).

  • y (ArrayLike) – Corresponding range variable \(y\).

Examples

>>> domain = np.arange(0, 10, 1)
>>> range_ = tstack([np.linspace(10, 100, 10)] * 3)
>>> range_ += np.array([0, 10, 20])
>>> multi_signals = MultiSignals(range_)
>>> print(multi_signals)
[[   0.   10.   20.   30.]
 [   1.   20.   30.   40.]
 [   2.   30.   40.   50.]
 [   3.   40.   50.   60.]
 [   4.   50.   60.   70.]
 [   5.   60.   70.   80.]
 [   6.   70.   80.   90.]
 [   7.   80.   90.  100.]
 [   8.   90.  100.  110.]
 [   9.  100.  110.  120.]]
>>> multi_signals[0] = 20
>>> multi_signals[0]
array([ 20.,  20.,  20.])
>>> multi_signals[np.array([0, 1, 2])] = 30
>>> multi_signals[np.array([0, 1, 2])]
array([[ 30.,  30.,  30.],
       [ 30.,  30.,  30.],
       [ 30.,  30.,  30.]])
>>> multi_signals[np.linspace(0, 5, 5)] = 50
>>> print(multi_signals)
[[   0.     50.     50.     50.  ]
 [   1.     30.     30.     30.  ]
 [   1.25   50.     50.     50.  ]
 [   2.     30.     30.     30.  ]
 [   2.5    50.     50.     50.  ]
 [   3.     40.     50.     60.  ]
 [   3.75   50.     50.     50.  ]
 [   4.     50.     60.     70.  ]
 [   5.     50.     50.     50.  ]
 [   6.     70.     80.     90.  ]
 [   7.     80.     90.    100.  ]
 [   8.     90.    100.    110.  ]
 [   9.    100.    110.    120.  ]]
>>> multi_signals[np.array([0, 1, 2])] = np.array([10, 20, 30])
>>> print(multi_signals)
[[   0.     10.     20.     30.  ]
 [   1.     10.     20.     30.  ]
 [   1.25   50.     50.     50.  ]
 [   2.     10.     20.     30.  ]
 [   2.5    50.     50.     50.  ]
 [   3.     40.     50.     60.  ]
 [   3.75   50.     50.     50.  ]
 [   4.     50.     60.     70.  ]
 [   5.     50.     50.     50.  ]
 [   6.     70.     80.     90.  ]
 [   7.     80.     90.    100.  ]
 [   8.     90.    100.    110.  ]
 [   9.    100.    110.    120.  ]]
>>> y = np.reshape(np.arange(1, 10, 1), (3, 3))
>>> multi_signals[np.array([0, 1, 2])] = y
>>> print(multi_signals)
[[   0.      1.      2.      3.  ]
 [   1.      4.      5.      6.  ]
 [   1.25   50.     50.     50.  ]
 [   2.      7.      8.      9.  ]
 [   2.5    50.     50.     50.  ]
 [   3.     40.     50.     60.  ]
 [   3.75   50.     50.     50.  ]
 [   4.     50.     60.     70.  ]
 [   5.     50.     50.     50.  ]
 [   6.     70.     80.     90.  ]
 [   7.     80.     90.    100.  ]
 [   8.     90.    100.    110.  ]
 [   9.    100.    110.    120.  ]]
>>> multi_signals[0:3] = 40
>>> multi_signals[0:3]
array([[ 40.,  40.,  40.],
       [ 40.,  40.,  40.],
       [ 40.,  40.,  40.]])
>>> multi_signals[:, 0:2] = 50
>>> print(multi_signals)
[[   0.     50.     50.     40.  ]
 [   1.     50.     50.     40.  ]
 [   1.25   50.     50.     40.  ]
 [   2.     50.     50.      9.  ]
 [   2.5    50.     50.     50.  ]
 [   3.     50.     50.     60.  ]
 [   3.75   50.     50.     50.  ]
 [   4.     50.     50.     70.  ]
 [   5.     50.     50.     50.  ]
 [   6.     50.     50.     90.  ]
 [   7.     50.     50.    100.  ]
 [   8.     50.     50.    110.  ]
 [   9.     50.     50.    120.  ]]
__contains__(x: ArrayLike | slice) bool[source]#

Return whether the multi-continuous signals contains given independent domain variable \(x\).

Parameters:

x (ArrayLike | slice) – Independent domain variable \(x\).

Returns:

Whether \(x\) domain value is contained.

Return type:

bool

Examples

>>> range_ = np.linspace(10, 100, 10)
>>> multi_signals = MultiSignals(range_)
>>> 0 in multi_signals
True
>>> 0.5 in multi_signals
True
>>> 1000 in multi_signals
False
__eq__(other: Any) bool[source]#

Return whether the multi-continuous signals is equal to given other object.

Parameters:

other (Any) – Object to test whether it is equal to the multi-continuous signals.

Returns:

Whether given object is equal to the multi-continuous signals.

Return type:

bool

Examples

>>> range_ = np.linspace(10, 100, 10)
>>> multi_signals_1 = MultiSignals(range_)
>>> multi_signals_2 = MultiSignals(range_)
>>> multi_signals_1 == multi_signals_2
True
>>> multi_signals_2[0] = 20
>>> multi_signals_1 == multi_signals_2
False
>>> multi_signals_2[0] = 10
>>> multi_signals_1 == multi_signals_2
True
>>> from colour.algebra import CubicSplineInterpolator
>>> multi_signals_2.interpolator = CubicSplineInterpolator
>>> multi_signals_1 == multi_signals_2
False
__ne__(other: Any) bool[source]#

Return whether the multi-continuous signals is not equal to given other object.

Parameters:

other (Any) – Object to test whether it is not equal to the multi-continuous signals.

Returns:

Whether given object is not equal to the multi-continuous signals.

Return type:

bool

Examples

>>> range_ = np.linspace(10, 100, 10)
>>> multi_signals_1 = MultiSignals(range_)
>>> multi_signals_2 = MultiSignals(range_)
>>> multi_signals_1 != multi_signals_2
False
>>> multi_signals_2[0] = 20
>>> multi_signals_1 != multi_signals_2
True
>>> multi_signals_2[0] = 10
>>> multi_signals_1 != multi_signals_2
False
>>> from colour.algebra import CubicSplineInterpolator
>>> multi_signals_2.interpolator = CubicSplineInterpolator
>>> multi_signals_1 != multi_signals_2
True
arithmetical_operation(a: ArrayLike | AbstractContinuousFunction, operation: Literal['+', '-', '*', '/', '**'], in_place: bool = False) MultiSignals[source]#

Perform given arithmetical operation with operand \(a\), the operation can be either performed on a copy or in-place.

Parameters:
  • a (ArrayLike | AbstractContinuousFunction) – Operand \(a\).

  • operation (Literal['+', '-', '*', '/', '**']) – Operation to perform.

  • in_place (bool) – Operation happens in place.

Returns:

multi-continuous signals.

Return type:

colour.continuous.MultiSignals

Examples

Adding a single numeric variable:

>>> domain = np.arange(0, 10, 1)
>>> range_ = tstack([np.linspace(10, 100, 10)] * 3)
>>> range_ += np.array([0, 10, 20])
>>> multi_signals_1 = MultiSignals(range_)
>>> print(multi_signals_1)
[[   0.   10.   20.   30.]
 [   1.   20.   30.   40.]
 [   2.   30.   40.   50.]
 [   3.   40.   50.   60.]
 [   4.   50.   60.   70.]
 [   5.   60.   70.   80.]
 [   6.   70.   80.   90.]
 [   7.   80.   90.  100.]
 [   8.   90.  100.  110.]
 [   9.  100.  110.  120.]]
>>> print(multi_signals_1.arithmetical_operation(10, "+", True))
[[   0.   20.   30.   40.]
 [   1.   30.   40.   50.]
 [   2.   40.   50.   60.]
 [   3.   50.   60.   70.]
 [   4.   60.   70.   80.]
 [   5.   70.   80.   90.]
 [   6.   80.   90.  100.]
 [   7.   90.  100.  110.]
 [   8.  100.  110.  120.]
 [   9.  110.  120.  130.]]

Adding an ArrayLike variable:

>>> a = np.linspace(10, 100, 10)
>>> print(multi_signals_1.arithmetical_operation(a, "+", True))
[[   0.   30.   40.   50.]
 [   1.   50.   60.   70.]
 [   2.   70.   80.   90.]
 [   3.   90.  100.  110.]
 [   4.  110.  120.  130.]
 [   5.  130.  140.  150.]
 [   6.  150.  160.  170.]
 [   7.  170.  180.  190.]
 [   8.  190.  200.  210.]
 [   9.  210.  220.  230.]]
>>> a = np.array([[10, 20, 30]])
>>> print(multi_signals_1.arithmetical_operation(a, "+", True))
[[   0.   40.   60.   80.]
 [   1.   60.   80.  100.]
 [   2.   80.  100.  120.]
 [   3.  100.  120.  140.]
 [   4.  120.  140.  160.]
 [   5.  140.  160.  180.]
 [   6.  160.  180.  200.]
 [   7.  180.  200.  220.]
 [   8.  200.  220.  240.]
 [   9.  220.  240.  260.]]
>>> a = np.reshape(np.arange(0, 30, 1), (10, 3))
>>> print(multi_signals_1.arithmetical_operation(a, "+", True))
[[   0.   40.   61.   82.]
 [   1.   63.   84.  105.]
 [   2.   86.  107.  128.]
 [   3.  109.  130.  151.]
 [   4.  132.  153.  174.]
 [   5.  155.  176.  197.]
 [   6.  178.  199.  220.]
 [   7.  201.  222.  243.]
 [   8.  224.  245.  266.]
 [   9.  247.  268.  289.]]

Adding a colour.continuous.Signal sub-class:

>>> multi_signals_2 = MultiSignals(range_)
>>> print(multi_signals_1.arithmetical_operation(multi_signals_2, "+", True))
[[   0.   50.   81.  112.]
 [   1.   83.  114.  145.]
 [   2.  116.  147.  178.]
 [   3.  149.  180.  211.]
 [   4.  182.  213.  244.]
 [   5.  215.  246.  277.]
 [   6.  248.  279.  310.]
 [   7.  281.  312.  343.]
 [   8.  314.  345.  376.]
 [   9.  347.  378.  409.]]
static multi_signals_unpack_data(data: ArrayLike | DataFrame | dict | MultiSignals | Sequence | Series | Signal | None = None, domain: ArrayLike | None = None, labels: Sequence | None = None, dtype: Type[DTypeFloat] | None = None, signal_type: Type[Signal] = Signal, **kwargs: Any) Dict[str, Signal][source]#

Unpack given data for multi-continuous signals instantiation.

Parameters:
Returns:

Mapping of labeled colour.continuous.Signal sub-class instances.

Return type:

dict

Examples

Unpacking using implicit domain and data for a single signal:

>>> range_ = np.linspace(10, 100, 10)
>>> signals = MultiSignals.multi_signals_unpack_data(range_)
>>> list(signals.keys())
['0']
>>> print(signals["0"])
[[   0.   10.]
 [   1.   20.]
 [   2.   30.]
 [   3.   40.]
 [   4.   50.]
 [   5.   60.]
 [   6.   70.]
 [   7.   80.]
 [   8.   90.]
 [   9.  100.]]

Unpacking using explicit domain and data for a single signal:

>>> domain = np.arange(100, 1100, 100)
>>> signals = MultiSignals.multi_signals_unpack_data(range_, domain)
>>> list(signals.keys())
['0']
>>> print(signals["0"])
[[  100.    10.]
 [  200.    20.]
 [  300.    30.]
 [  400.    40.]
 [  500.    50.]
 [  600.    60.]
 [  700.    70.]
 [  800.    80.]
 [  900.    90.]
 [ 1000.   100.]]

Unpacking using data for multiple signals:

>>> range_ = tstack([np.linspace(10, 100, 10)] * 3)
>>> range_ += np.array([0, 10, 20])
>>> signals = MultiSignals.multi_signals_unpack_data(range_, domain)
>>> list(signals.keys())
['0', '1', '2']
>>> print(signals["2"])
[[  100.    30.]
 [  200.    40.]
 [  300.    50.]
 [  400.    60.]
 [  500.    70.]
 [  600.    80.]
 [  700.    90.]
 [  800.   100.]
 [  900.   110.]
 [ 1000.   120.]]

Unpacking using a dict:

>>> signals = MultiSignals.multi_signals_unpack_data(dict(zip(domain, range_)))
>>> list(signals.keys())
['0', '1', '2']
>>> print(signals["2"])
[[  100.    30.]
 [  200.    40.]
 [  300.    50.]
 [  400.    60.]
 [  500.    70.]
 [  600.    80.]
 [  700.    90.]
 [  800.   100.]
 [  900.   110.]
 [ 1000.   120.]]

Unpacking using a sequence of Signal instances, note how the keys are str instances because the Signal names are used:

>>> signals = MultiSignals.multi_signals_unpack_data(
...     dict(zip(domain, range_))
... ).values()
>>> signals = MultiSignals.multi_signals_unpack_data(signals)
>>> list(signals.keys())
['0', '1', '2']
>>> print(signals["2"])
[[  100.    30.]
 [  200.    40.]
 [  300.    50.]
 [  400.    60.]
 [  500.    70.]
 [  600.    80.]
 [  700.    90.]
 [  800.   100.]
 [  900.   110.]
 [ 1000.   120.]]

Unpacking using MultiSignals.multi_signals_unpack_data method output:

>>> signals = MultiSignals.multi_signals_unpack_data(dict(zip(domain, range_)))
>>> signals = MultiSignals.multi_signals_unpack_data(signals)
>>> list(signals.keys())
['0', '1', '2']
>>> print(signals["2"])
[[  100.    30.]
 [  200.    40.]
 [  300.    50.]
 [  400.    60.]
 [  500.    70.]
 [  600.    80.]
 [  700.    90.]
 [  800.   100.]
 [  900.   110.]
 [ 1000.   120.]]

Unpacking using a Pandas Series:

>>> if is_pandas_installed():
...     from pandas import Series
...
...     signals = MultiSignals.multi_signals_unpack_data(
...         Series(dict(zip(domain, np.linspace(10, 100, 10))))
...     )
...     print(signals[0])  
[[  100.    10.]
 [  200.    20.]
 [  300.    30.]
 [  400.    40.]
 [  500.    50.]
 [  600.    60.]
 [  700.    70.]
 [  800.    80.]
 [  900.    90.]
 [ 1000.   100.]]

Unpacking using a Pandas pandas.DataFrame:

>>> if is_pandas_installed():
...     from pandas import DataFrame
...
...     data = dict(zip(["a", "b", "c"], tsplit(range_)))
...     signals = MultiSignals.multi_signals_unpack_data(
...         DataFrame(data, domain)
...     )
...     print(signals["c"])  
[[  100.    30.]
 [  200.    40.]
 [  300.    50.]
 [  400.    60.]
 [  500.    70.]
 [  600.    80.]
 [  700.    90.]
 [  800.   100.]
 [  900.   110.]
 [ 1000.   120.]]
fill_nan(method: Literal['Interpolation', 'Constant'] | str = 'Interpolation', default: Real = 0) MultiSignals[source]#

Fill NaNs in independent domain variable \(x\) and corresponding range variable \(y\) using given method.

Parameters:
  • method (Literal['Interpolation', 'Constant'] | str) – Interpolation method linearly interpolates through the NaNs, Constant method replaces NaNs with default.

  • default (Real) – Value to use with the Constant method.

Returns:

  • colour.continuous.MultiSignals – NaNs filled multi-continuous signals.

  • >>> domain = np.arange(0, 10, 1)

  • >>> range_ = tstack([np.linspace(10, 100, 10)] * 3)

  • >>> range_ += np.array([0, 10, 20])

  • >>> multi_signals = MultiSignals(range_)

  • >>> multi_signals[3 (7] = np.nan)

  • >>> print(multi_signals)

  • [[ 0. 10. 20. 30.] – [ 1. 20. 30. 40.] [ 2. 30. 40. 50.] [ 3. nan nan nan] [ 4. nan nan nan] [ 5. nan nan nan] [ 6. nan nan nan] [ 7. 80. 90. 100.] [ 8. 90. 100. 110.] [ 9. 100. 110. 120.]]

  • >>> print(multi_signals.fill_nan())

  • [[ 0. 10. 20. 30.] – [ 1. 20. 30. 40.] [ 2. 30. 40. 50.] [ 3. 40. 50. 60.] [ 4. 50. 60. 70.] [ 5. 60. 70. 80.] [ 6. 70. 80. 90.] [ 7. 80. 90. 100.] [ 8. 90. 100. 110.] [ 9. 100. 110. 120.]]

  • >>> multi_signals[3 (7] = np.nan)

  • >>> print(multi_signals.fill_nan(method=”Constant”))

  • [[ 0. 10. 20. 30.] – [ 1. 20. 30. 40.] [ 2. 30. 40. 50.] [ 3. 0. 0. 0.] [ 4. 0. 0. 0.] [ 5. 0. 0. 0.] [ 6. 0. 0. 0.] [ 7. 80. 90. 100.] [ 8. 90. 100. 110.] [ 9. 100. 110. 120.]]

Return type:

MultiSignals

to_dataframe() DataFrame[source]#

Convert the continuous signal to a Pandas pandas.DataFrame class instance.

Returns:

Continuous signal as a Pandas pandas.DataFrame class instance.

Return type:

pandas.DataFrame

Examples

>>> if is_pandas_installed():
...     domain = np.arange(0, 10, 1)
...     range_ = tstack([np.linspace(10, 100, 10)] * 3)
...     range_ += np.array([0, 10, 20])
...     multi_signals = MultiSignals(range_)
...     print(multi_signals.to_dataframe())  
         0      1      2
0.0   10.0   20.0   30.0
1.0   20.0   30.0   40.0
2.0   30.0   40.0   50.0
3.0   40.0   50.0   60.0
4.0   50.0   60.0   70.0
5.0   60.0   70.0   80.0
6.0   70.0   80.0   90.0
7.0   80.0   90.0  100.0
8.0   90.0  100.0  110.0
9.0  100.0  110.0  120.0