phylogenie 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

phylogenie/core/trees/remaster/factories.py

@@ -1,17 +1,14 @@
 import phylogenie.core.trees.remaster.configs as cfg
+import phylogenie.typings as pgt
 from phylogenie.backend.remaster import PunctualReaction, Reaction
 from phylogenie.core.factories import (
-    one_or_many_ints_factory,
-    one_or_many_scalars_factory,
+    many_ints_factory,
+    many_scalars_factory,
     skyline_parameter_like_factory,
 )
-from phylogenie.core.typings import Data
 
 
-def reaction_factory(
-    x: cfg.ReactionConfig,
-    data: Data,
-) -> Reaction:
+def reaction_factory(x: cfg.ReactionConfig, data: pgt.Data) -> Reaction:
     return Reaction(
         rate=skyline_parameter_like_factory(x.rate, data),
         value=x.value,
@@ -19,12 +16,11 @@ def reaction_factory(
 
 
 def punctual_reaction_factory(
-    x: cfg.PunctualReactionConfig,
-    data: Data,
+    x: cfg.PunctualReactionConfig, data: pgt.Data
 ) -> PunctualReaction:
     return PunctualReaction(
-        times=one_or_many_scalars_factory(x.times, data),
+        times=many_scalars_factory(x.times, data),
         value=x.value,
-        p=None if x.p is None else one_or_many_scalars_factory(x.p, data),
-        n=None if x.n is None else one_or_many_ints_factory(x.n, data),
+        p=None if x.p is None else many_scalars_factory(x.p, data),
+        n=None if x.n is None else many_ints_factory(x.n, data),
     )

phylogenie/core/trees/remaster/generator.py

@@ -6,6 +6,7 @@ from numpy.random import Generator
 from pydantic import Field
 
 import phylogenie.core.configs as cfg
+import phylogenie.typings as pgt
 from phylogenie.backend.remaster import (
     DEFAULT_POPULATION,
     SAMPLE_POPULATION,
@@ -16,8 +17,8 @@ from phylogenie.backend.remaster import (
     get_FBD_reactions,
 )
 from phylogenie.core.factories import (
-    skyline_matrix_like_factory,
-    skyline_vector_like_factory,
+    skyline_matrix_coercible_factory,
+    skyline_vector_coercible_factory,
 )
 from phylogenie.core.trees.base import BackendType, TreesGenerator
 from phylogenie.core.trees.remaster.configs import (
@@ -28,7 +29,6 @@ from phylogenie.core.trees.remaster.factories import (
     punctual_reaction_factory,
     reaction_factory,
 )
-from phylogenie.core.typings import Data
 
 
 class ParameterizationType(str, Enum):
@@ -39,6 +39,7 @@ class ParameterizationType(str, Enum):
 
 class ReMASTERGenerator(TreesGenerator):
     backend: Literal[BackendType.REMASTER] = BackendType.REMASTER
+    beast_path: str = "beast"
     populations: str | list[str] = DEFAULT_POPULATION
     init_population: str = DEFAULT_POPULATION
     sample_population: str = SAMPLE_POPULATION
@@ -47,7 +48,7 @@ class ReMASTERGenerator(TreesGenerator):
     trajectory_attrs: dict[str, str | int | float] = Field(default_factory=dict)
 
     def _generate_one_from_extra_reactions(
-        self, filename: str, rng: Generator, data: Data, reactions: list[Reaction]
+        self, filename: str, rng: Generator, data: pgt.Data, reactions: list[Reaction]
     ) -> None:
         generate_trees(
             tree_file_name=f"{filename}.nwk",
@@ -63,9 +64,10 @@ class ReMASTERGenerator(TreesGenerator):
                 for k, v in self.trajectory_attrs.items()
             },
             seed=int(rng.integers(0, 2**31 - 1)),
+            beast_path=self.beast_path,
         )
 
-    def _generate_one(self, filename: str, rng: Generator, data: Data) -> None:
+    def _generate_one(self, filename: str, rng: Generator, data: pgt.Data) -> None:
         self._generate_one_from_extra_reactions(filename, rng, data, reactions=[])
 
 
@@ -73,25 +75,27 @@ class CanonicalReMASTERGenerator(ReMASTERGenerator):
     parameterization: Literal[ParameterizationType.CANONICAL] = (
         ParameterizationType.CANONICAL
     )
-    birth_rates: cfg.SkylineVectorLikeConfig = 0
-    death_rates: cfg.SkylineVectorLikeConfig = 0
-    sampling_rates: cfg.SkylineVectorLikeConfig = 0
-    removal_probabilities: cfg.SkylineVectorLikeConfig = 0
-    migration_rates: cfg.SkylineMatrixLikeConfig = 0
-    birth_rates_among_demes: cfg.SkylineMatrixLikeConfig = 0
-
-    def _generate_one(self, filename: str, rng: Generator, data: Data) -> None:
+    birth_rates: cfg.SkylineVectorCoercibleConfig = 0
+    death_rates: cfg.SkylineVectorCoercibleConfig = 0
+    sampling_rates: cfg.SkylineVectorCoercibleConfig = 0
+    removal_probabilities: cfg.SkylineVectorCoercibleConfig = 0
+    migration_rates: cfg.SkylineMatrixCoercibleConfig = 0
+    birth_rates_among_demes: cfg.SkylineMatrixCoercibleConfig = 0
+
+    def _generate_one(self, filename: str, rng: Generator, data: pgt.Data) -> None:
         reactions = get_canonical_reactions(
             populations=self.populations,
             sample_population=self.sample_population,
-            birth_rates=skyline_vector_like_factory(self.birth_rates, data),
-            death_rates=skyline_vector_like_factory(self.death_rates, data),
-            sampling_rates=skyline_vector_like_factory(self.sampling_rates, data),
-            removal_probabilities=skyline_vector_like_factory(
+            birth_rates=skyline_vector_coercible_factory(self.birth_rates, data),
+            death_rates=skyline_vector_coercible_factory(self.death_rates, data),
+            sampling_rates=skyline_vector_coercible_factory(self.sampling_rates, data),
+            removal_probabilities=skyline_vector_coercible_factory(
                 self.removal_probabilities, data
             ),
-            migration_rates=skyline_matrix_like_factory(self.migration_rates, data),
-            birth_rates_among_demes=skyline_matrix_like_factory(
+            migration_rates=skyline_matrix_coercible_factory(
+                self.migration_rates, data
+            ),
+            birth_rates_among_demes=skyline_matrix_coercible_factory(
                 self.birth_rates_among_demes, data
             ),
         )
@@ -102,31 +106,33 @@ class EpidemiologicalReMASTERGenerator(ReMASTERGenerator):
     parameterization: Literal[ParameterizationType.EPIDEMIOLOGICAL] = (
         ParameterizationType.EPIDEMIOLOGICAL
     )
-    reproduction_numbers: cfg.SkylineVectorLikeConfig = 0
-    become_uninfectious_rates: cfg.SkylineVectorLikeConfig = 0
-    sampling_proportions: cfg.SkylineVectorLikeConfig = 0
-    removal_probabilities: cfg.SkylineVectorLikeConfig = 0
-    migration_rates: cfg.SkylineMatrixLikeConfig = 0
-    reproduction_numbers_among_demes: cfg.SkylineMatrixLikeConfig = 0
-
-    def _generate_one(self, filename: str, rng: Generator, data: Data) -> None:
+    reproduction_numbers: cfg.SkylineVectorCoercibleConfig = 0
+    become_uninfectious_rates: cfg.SkylineVectorCoercibleConfig = 0
+    sampling_proportions: cfg.SkylineVectorCoercibleConfig = 0
+    removal_probabilities: cfg.SkylineVectorCoercibleConfig = 0
+    migration_rates: cfg.SkylineMatrixCoercibleConfig = 0
+    reproduction_numbers_among_demes: cfg.SkylineMatrixCoercibleConfig = 0
+
+    def _generate_one(self, filename: str, rng: Generator, data: pgt.Data) -> None:
         reactions = get_epidemiological_reactions(
             populations=self.populations,
             sample_population=self.sample_population,
-            reproduction_numbers=skyline_vector_like_factory(
+            reproduction_numbers=skyline_vector_coercible_factory(
                 self.reproduction_numbers, data
             ),
-            become_uninfectious_rates=skyline_vector_like_factory(
+            become_uninfectious_rates=skyline_vector_coercible_factory(
                 self.become_uninfectious_rates, data
             ),
-            sampling_proportions=skyline_vector_like_factory(
+            sampling_proportions=skyline_vector_coercible_factory(
                 self.sampling_proportions, data
             ),
-            removal_probabilities=skyline_vector_like_factory(
+            removal_probabilities=skyline_vector_coercible_factory(
                 self.removal_probabilities, data
             ),
-            migration_rates=skyline_matrix_like_factory(self.migration_rates, data),
-            reproduction_numbers_among_demes=skyline_matrix_like_factory(
+            migration_rates=skyline_matrix_coercible_factory(
+                self.migration_rates, data
+            ),
+            reproduction_numbers_among_demes=skyline_matrix_coercible_factory(
                 self.reproduction_numbers_among_demes, data
             ),
         )
@@ -135,27 +141,31 @@ class EpidemiologicalReMASTERGenerator(ReMASTERGenerator):
 
 class FBDReMASTERGenerator(ReMASTERGenerator):
     parameterization: Literal[ParameterizationType.FBD] = ParameterizationType.FBD
-    diversification: cfg.SkylineVectorLikeConfig = 0
-    turnover: cfg.SkylineVectorLikeConfig = 0
-    sampling_proportions: cfg.SkylineVectorLikeConfig = 0
-    removal_probabilities: cfg.SkylineVectorLikeConfig = 0
-    migration_rates: cfg.SkylineMatrixLikeConfig = 0
-    diversification_between_types: cfg.SkylineMatrixLikeConfig = 0
-
-    def _generate_one(self, filename: str, rng: Generator, data: Data) -> None:
+    diversification: cfg.SkylineVectorCoercibleConfig = 0
+    turnover: cfg.SkylineVectorCoercibleConfig = 0
+    sampling_proportions: cfg.SkylineVectorCoercibleConfig = 0
+    removal_probabilities: cfg.SkylineVectorCoercibleConfig = 0
+    migration_rates: cfg.SkylineMatrixCoercibleConfig = 0
+    diversification_between_types: cfg.SkylineMatrixCoercibleConfig = 0
+
+    def _generate_one(self, filename: str, rng: Generator, data: pgt.Data) -> None:
         reactions = get_FBD_reactions(
             populations=self.populations,
             sample_population=self.sample_population,
-            diversification=skyline_vector_like_factory(self.diversification, data),
-            turnover=skyline_vector_like_factory(self.turnover, data),
-            sampling_proportions=skyline_vector_like_factory(
+            diversification=skyline_vector_coercible_factory(
+                self.diversification, data
+            ),
+            turnover=skyline_vector_coercible_factory(self.turnover, data),
+            sampling_proportions=skyline_vector_coercible_factory(
                 self.sampling_proportions, data
             ),
-            removal_probabilities=skyline_vector_like_factory(
+            removal_probabilities=skyline_vector_coercible_factory(
                 self.removal_probabilities, data
             ),
-            migration_rates=skyline_matrix_like_factory(self.migration_rates, data),
-            diversification_between_types=skyline_matrix_like_factory(
+            migration_rates=skyline_matrix_coercible_factory(
+                self.migration_rates, data
+            ),
+            diversification_between_types=skyline_matrix_coercible_factory(
                 self.diversification_between_types, data
             ),
         )

phylogenie/core/trees/treesimulator.py

@@ -6,6 +6,7 @@ from numpy.random import Generator
 from pydantic import Field
 
 import phylogenie.core.configs as cfg
+import phylogenie.typings as pgt
 from phylogenie.backend.treesimulator import (
     DEFAULT_POPULATION,
     TreeParams,
@@ -16,12 +17,11 @@ from phylogenie.backend.treesimulator import (
 from phylogenie.core.factories import (
     int_factory,
     scalar_factory,
-    skyline_matrix_like_factory,
+    skyline_matrix_coercible_factory,
     skyline_parameter_like_factory,
-    skyline_vector_like_factory,
+    skyline_vector_coercible_factory,
 )
 from phylogenie.core.trees.base import BackendType, TreesGenerator
-from phylogenie.core.typings import Data
 
 
 class ParameterizationType(str, Enum):
@@ -35,15 +35,15 @@ class TreeSimulatorGenerator(TreesGenerator):
     min_tips: cfg.IntConfig
     max_tips: cfg.IntConfig
     T: cfg.ScalarConfig = np.inf
+    root_state: str | None = None
     state_frequencies: list[float] | None = None
     notification_probability: cfg.SkylineParameterLikeConfig = 0
     notification_sampling_rate: cfg.SkylineParameterLikeConfig = np.inf
     allow_irremovable_states: bool = False
     max_notified_contacts: cfg.IntConfig = 1
-    root_state: str | None = None
 
     def _generate_one_from_params(
-        self, filename: str, rng: Generator, data: Data, params: TreeParams
+        self, filename: str, rng: Generator, data: pgt.Data, params: TreeParams
     ) -> None:
         root_state = (
             self.root_state
@@ -75,26 +75,28 @@ class CanonicalTreeSimulatorGenerator(TreeSimulatorGenerator):
         ParameterizationType.CANONICAL
     )
     populations: str | list[str] = DEFAULT_POPULATION
-    transition_rates: cfg.SkylineMatrixLikeConfig = 0
-    transmission_rates: cfg.SkylineMatrixLikeConfig = 0
-    removal_rates: cfg.SkylineVectorLikeConfig = 0
-    sampling_proportions: cfg.SkylineVectorLikeConfig = 0
+    transition_rates: cfg.SkylineMatrixCoercibleConfig = 0
+    transmission_rates: cfg.SkylineMatrixCoercibleConfig = 0
+    removal_rates: cfg.SkylineVectorCoercibleConfig = 0
+    sampling_proportions: cfg.SkylineVectorCoercibleConfig = 0
 
-    def _generate_one(self, filename: str, rng: Generator, data: Data) -> None:
+    def _generate_one(self, filename: str, rng: Generator, data: pgt.Data) -> None:
         self._generate_one_from_params(
             filename,
             rng,
             data,
             TreeParams(
                 populations=self.populations,
-                transition_rates=skyline_matrix_like_factory(
+                transition_rates=skyline_matrix_coercible_factory(
                     self.transition_rates, data
                 ),
-                transmission_rates=skyline_matrix_like_factory(
+                transmission_rates=skyline_matrix_coercible_factory(
                     self.transmission_rates, data
                 ),
-                removal_rates=skyline_vector_like_factory(self.removal_rates, data),
-                sampling_proportions=skyline_vector_like_factory(
+                removal_rates=skyline_vector_coercible_factory(
+                    self.removal_rates, data
+                ),
+                sampling_proportions=skyline_vector_coercible_factory(
                     self.sampling_proportions, data
                 ),
             ),
@@ -107,7 +109,7 @@ class BDTreeSimulatorGenerator(TreeSimulatorGenerator):
     infectious_period: cfg.SkylineParameterLikeConfig = 0
     sampling_proportion: cfg.SkylineParameterLikeConfig = 0
 
-    def _generate_one(self, filename: str, rng: Generator, data: Data) -> None:
+    def _generate_one(self, filename: str, rng: Generator, data: pgt.Data) -> None:
         self._generate_one_from_params(
             filename,
             rng,
@@ -133,7 +135,7 @@ class BDEITreeSimulatorGenerator(TreeSimulatorGenerator):
     incubation_period: cfg.SkylineParameterLikeConfig = 0
     sampling_proportion: cfg.SkylineParameterLikeConfig = 0
 
-    def _generate_one(self, filename: str, rng: Generator, data: Data) -> None:
+    def _generate_one(self, filename: str, rng: Generator, data: pgt.Data) -> None:
         self._generate_one_from_params(
             filename,
             rng,

phylogenie/core/typeguards.py

@@ -1,35 +1,27 @@
 from typing import TypeGuard
 
 import phylogenie.core.configs as cfg
-import phylogenie.typeguards as tg
-import phylogenie.typings as pgt
 
 
-def is_many_scalar_configs(x: object) -> TypeGuard[pgt.Many[cfg.ScalarConfig]]:
-    return tg.is_many(x) and all(isinstance(v, cfg.ScalarConfig) for v in x)
+def is_list(x: object) -> TypeGuard[list[object]]:
+    return isinstance(x, list)
 
 
-def is_many_2D_scalar_configs(x: object) -> TypeGuard[pgt.Many2D[cfg.ScalarConfig]]:
-    return tg.is_many(x) and all(is_many_scalar_configs(v) for v in x)
+def is_list_of_scalar_configs(x: object) -> TypeGuard[list[cfg.ScalarConfig]]:
+    return is_list(x) and all(isinstance(v, cfg.ScalarConfig) for v in x)
 
 
-def is_many_3D_scalar_configs(x: object) -> TypeGuard[pgt.Many3D[cfg.ScalarConfig]]:
-    return tg.is_many(x) and all(is_many_2D_scalar_configs(v) for v in x)
-
-
-def is_many_skyline_parameter_like_configs(
+def is_list_of_skyline_parameter_like_configs(
     x: object,
-) -> TypeGuard[pgt.Many[cfg.SkylineParameterLikeConfig]]:
-    return tg.is_many(x) and all(
-        isinstance(v, cfg.SkylineParameterLikeConfig) for v in x
-    )
+) -> TypeGuard[list[cfg.SkylineParameterLikeConfig]]:
+    return is_list(x) and all(isinstance(v, cfg.SkylineParameterLikeConfig) for v in x)
 
 
-def is_many_skyline_vector_like_configs(
+def is_list_of_skyline_vector_like_configs(
     x: object,
-) -> TypeGuard[pgt.Many[cfg.SkylineVectorLikeConfig]]:
-    return tg.is_many(x) and all(
-        isinstance(v, str | pgt.Scalar | cfg.SkylineVectorValueModel)
-        or is_many_skyline_parameter_like_configs(v)
+) -> TypeGuard[list[cfg.SkylineVectorLikeConfig]]:
+    return is_list(x) and all(
+        isinstance(v, str | cfg.SkylineVectorValueModel)
+        or is_list_of_skyline_parameter_like_configs(v)
         for v in x
     )

phylogenie/skyline/__init__.py

@@ -1,19 +1,29 @@
-from phylogenie.skyline.matrix import SkylineMatrix, SkylineMatrixLike, skyline_matrix
+from phylogenie.skyline.matrix import (
+    SkylineMatrix,
+    SkylineMatrixCoercible,
+    skyline_matrix,
+)
 from phylogenie.skyline.parameter import (
     SkylineParameter,
     SkylineParameterLike,
     skyline_parameter,
 )
-from phylogenie.skyline.vector import SkylineVector, SkylineVectorLike, skyline_vector
+from phylogenie.skyline.vector import (
+    SkylineVector,
+    SkylineVectorCoercible,
+    SkylineVectorLike,
+    skyline_vector,
+)
 
 __all__ = [
     "skyline_matrix",
     "skyline_parameter",
     "skyline_vector",
+    "SkylineMatrix",
+    "SkylineMatrixCoercible",
     "SkylineParameter",
     "SkylineParameterLike",
     "SkylineVector",
+    "SkylineVectorCoercible",
     "SkylineVectorLike",
-    "SkylineMatrix",
-    "SkylineMatrixLike",
 ]

phylogenie/skyline/matrix.py

@@ -1,12 +1,13 @@
 from collections.abc import Callable, Iterator
-from typing import TypeGuard, Union, overload
+from typing import TypeGuard, Union
 
 import phylogenie.typeguards as tg
 import phylogenie.typings as pgt
 from phylogenie.skyline.parameter import (
+    SkylineParameter,
     SkylineParameterLike,
-    is_many_skyline_parameters_like,
     is_skyline_parameter_like,
+    skyline_parameter,
 )
 from phylogenie.skyline.vector import (
     SkylineVector,
@@ -18,51 +19,46 @@ from phylogenie.skyline.vector import (
     skyline_vector,
 )
 
-SkylineVector2D = pgt.Many[pgt.Many[SkylineParameterLike] | SkylineVector]
-SkylineMatrixParams = SkylineParameterLike | SkylineVector | SkylineVector2D
 SkylineMatrixOperand = Union[SkylineVectorOperand, "SkylineMatrix"]
-SkylineMatrixLike = Union[pgt.OneOrMany[SkylineVectorLike], "SkylineMatrix"]
+SkylineMatrixCoercible = Union[
+    SkylineParameterLike, pgt.Many[SkylineVectorLike], "SkylineMatrix"
+]
 
 
-def is_skyline_vector2D(value: object) -> TypeGuard[SkylineVector2D]:
-    return tg.is_many(value) and all(
-        isinstance(v, SkylineVector) or is_many_skyline_parameters_like(v)
-        for v in value
-    )
+def is_skyline_matrix_operand(x: object) -> TypeGuard[SkylineMatrixOperand]:
+    return isinstance(x, SkylineMatrix) or is_skyline_vector_operand(x)
 
 
 class SkylineMatrix:
     def __init__(
         self,
-        params: SkylineMatrixParams | None = None,
-        value: pgt.Many[pgt.OneOrMany2DScalars] | None = None,
-        change_times: pgt.OneOrManyScalars | None = None,
+        params: pgt.Many[SkylineVectorLike] | None = None,
+        value: pgt.Many3DScalars | None = None,
+        change_times: pgt.ManyScalars | None = None,
     ):
         if params is not None and value is None and change_times is None:
-            if is_skyline_parameter_like(params) or isinstance(params, SkylineVector):
-                self.params = [skyline_vector(params, 1)]
-            elif is_skyline_vector2D(params):
-                self.params = [skyline_vector(param, N=len(params)) for param in params]
+            if is_many_skyline_vectors_like(params):
+                self.params = [skyline_vector(p, len(params)) for p in params]
             else:
                 raise TypeError(
-                    f"It is impossible to create a SkylineMatrix from `params` {params} of type {type(params)}.Please provide either:\n"
-                    "- a SkylineParameterLike object (i.e., a SkylineParameter or a scalar),\n"
-                    "- a SkylineVector,\n"
-                    "- or a SkylineVector2D: a sequence containing SkylineVectors and/or sequences of SkylineParameterLike objects."
+                    f"It is impossible to create a SkylineMatrix from `params` {params} of type {type(params)}. Please provide a sequence composed of SkylineVectorLike objects (a SkylineVectorLike object can either be a SkylineVector or a sequence of scalars and/or SkylineParameters)."
                 )
         elif value is not None and change_times is not None:
-            Ns = {len(matrix) for matrix in value if tg.is_many(matrix)}
-            if len(Ns) > 1:
-                raise ValueError(
-                    f"All matrices in the `value` must be scalars or have the same length to create a SkylineMatrix (got value={value} with row lengths={Ns})."
+            if tg.is_many_3D_scalars(value):
+                matrix_lengths = {len(matrix) for matrix in value}
+                if any(ml != len(value[0]) for ml in matrix_lengths):
+                    raise ValueError(
+                        f"All matrices in the `value` of a SkylineMatrix must have the same length (got value={value} with matrix lengths={matrix_lengths})."
+                    )
+            else:
+                raise TypeError(
+                    f"It is impossible to create a SkylineMatrix from `value` {value} of type {type(value)}. Please provide a nested (3D) sequence of scalar values."
                 )
-            N = Ns.pop() if Ns else 1
-            value = [[[x] * N] * N if isinstance(x, pgt.Scalar) else x for x in value]
             self.params = [
                 SkylineVector(
                     value=[matrix[i] for matrix in value], change_times=change_times
                 )
-                for i in range(N)
+                for i in range(len(value[0]))
             ]
         else:
             raise ValueError(
@@ -75,23 +71,27 @@ class SkylineMatrix:
 
     @property
     def change_times(self) -> pgt.Vector1D:
-        return tuple(sorted(set([t for row in self.params for t in row.change_times])))
+        return sorted(set([t for row in self.params for t in row.change_times]))
 
     @property
     def value(self) -> pgt.Vector3D:
-        return tuple(self.get_value_at_time(t) for t in (0, *self.change_times))
+        return [self.get_value_at_time(t) for t in (0, *self.change_times)]
 
     def get_value_at_time(self, time: pgt.Scalar) -> pgt.Vector2D:
-        return tuple(param.get_value_at_time(time) for param in self.params)
+        return [param.get_value_at_time(time) for param in self.params]
 
     def operate(
         self,
         other: SkylineMatrixOperand,
-        func: Callable[[SkylineVector, SkylineVector], SkylineVector],
+        func: Callable[
+            [SkylineVector, SkylineVector | SkylineParameter], SkylineVector
+        ],
     ) -> "SkylineMatrix":
         if not is_skyline_matrix_operand(other):
             return NotImplemented
-        other = skyline_matrix(other, self.N)
+        if is_skyline_vector_operand(other):
+            other = skyline_vector(other, N=self.N)
+        assert isinstance(other, SkylineVector | SkylineMatrix)
         return SkylineMatrix(
             [func(p1, p2) for p1, p2 in zip(self.params, other.params)]
         )
@@ -139,40 +139,34 @@ class SkylineMatrix:
     def __len__(self) -> int:
         return self.N
 
-    @overload
-    def __getitem__(self, item: int) -> SkylineVector: ...
-    @overload
-    def __getitem__(self, item: slice) -> "SkylineMatrix": ...
-    def __getitem__(self, item: int | slice) -> "SkylineVector | SkylineMatrix":
-        if isinstance(item, slice):
-            return SkylineMatrix(self.params[item])
+    def __getitem__(self, item: int) -> "SkylineVector":
         return self.params[item]
 
     def __setitem__(self, item: int, value: SkylineVectorLike) -> None:
         if not is_skyline_vector_like(value):
-            raise TypeError(f"Expected a SkylineVectorLike, got {type(value)}.")
+            raise TypeError(
+                f"It is impossible to set item {item} of SkylineMatrix with value {value} of type {type(value)}. Please provide a SkylineVectorLike object (i.e., a SkylineVector or a sequence of scalars and/or SkylineParameters)."
+            )
         self.params[item] = skyline_vector(value, N=self.N)
 
 
 def skyline_matrix(
-    x: SkylineMatrixLike, N: int, zero_diagonal: bool = False
+    x: SkylineMatrixCoercible, N: int, zero_diagonal: bool = False
 ) -> SkylineMatrix:
-    if is_skyline_vector_like(x):
-        x = SkylineMatrix([skyline_vector(x, N)] * N)
+    if is_skyline_parameter_like(x):
+        x = SkylineMatrix([[skyline_parameter(x)] * N] * N)
         if zero_diagonal:
             for i in range(N):
                 x[i][i] = 0
-        return x.T
-
-    if is_many_skyline_vectors_like(x):
-        x = SkylineMatrix([skyline_vector(v, N) for v in x])
-
+        return x
+    elif is_many_skyline_vectors_like(x):
+        x = SkylineMatrix(x)
     if not isinstance(x, SkylineMatrix):
         raise TypeError(
             f"It is impossible to coerce {x} of type {type(x)} into a SkylineMatrix. Please provide either:\n"
             "- a SkylineMatrix,\n"
-            "- a SkylineVectorLike: a SkylineParameterLike (i.e., a SkylineParameter or a scalar) or a sequence of them,\n"
-            "- or a sequence of SkylineVectorLike objects."
+            "- a SkylineParameterLike object (i.e., a scalar or a SkylineParameter),\n"
+            "- a sequence of SkylineVectorLike objects (a SkylineVectorLike object can be a SkylineVector or a sequence of SkylineParameterLike objects)."
         )
 
     if x.N != N:
@@ -184,7 +178,3 @@ def skyline_matrix(
         raise ValueError(f"Expected a SkylineMatrix with zero diagonal, but got {x}.")
 
     return x
-
-
-def is_skyline_matrix_operand(x: object) -> TypeGuard[SkylineMatrixOperand]:
-    return isinstance(x, SkylineMatrix) or is_skyline_vector_operand(x)

phylogenie/skyline/parameter.py

@@ -4,32 +4,51 @@ from typing import TypeGuard, Union
 
 import phylogenie.typeguards as tg
 import phylogenie.typings as pgt
-from phylogenie.utils import vectorify1D
 
 SkylineParameterLike = Union[pgt.Scalar, "SkylineParameter"]
 
 
+def is_skyline_parameter_like(x: object) -> TypeGuard[SkylineParameterLike]:
+    return isinstance(x, pgt.Scalar | SkylineParameter)
+
+
+def is_many_skyline_parameters_like(
+    x: object,
+) -> TypeGuard[pgt.Many[SkylineParameterLike]]:
+    return tg.is_many(x) and all(is_skyline_parameter_like(v) for v in x)
+
+
 class SkylineParameter:
     def __init__(
         self,
         value: pgt.OneOrManyScalars,
-        change_times: pgt.OneOrManyScalars | None = None,
+        change_times: pgt.ManyScalars | None = None,
     ) -> None:
-        value = vectorify1D(value)
-        change_times = vectorify1D(change_times)
+        if isinstance(value, pgt.Scalar):
+            value = [value]
+        elif not tg.is_many_scalars(value):
+            raise TypeError(
+                f"It is impossible to create a SkylineParameter from `value` {value} of type {type(value)}. Please provide a scalar or a sequence of scalars."
+            )
+
+        if change_times is None:
+            change_times = []
+        elif not tg.is_many_scalars(change_times):
+            raise TypeError(
+                f"It is impossible to create a SkylineParameter from `change_times` {change_times} of type {type(change_times)}. Please provide a sequence of scalars."
+            )
+
         if len(value) != len(change_times) + 1:
             raise ValueError(
                 f"`value` must have exactly one more element than `change_times` (got value={value} of length {len(value)} and change_times={change_times} of length {len(change_times)})."
             )
 
-        value_ = [value[0]]
-        change_times_: list[pgt.Scalar] = []
+        self.value = [value[0]]
+        self.change_times: list[pgt.Scalar] = []
         for i in range(1, len(value)):
             if value[i] != value[i - 1]:
-                value_.append(value[i])
-                change_times_.append(change_times[i - 1])
-        self.value = tuple(value_)
-        self.change_times = tuple(change_times_)
+                self.value.append(value[i])
+                self.value.append(change_times[i - 1])
 
     def get_value_at_time(self, t: pgt.Scalar) -> pgt.Scalar:
         return self.value[bisect_right(self.change_times, t)]
@@ -85,13 +104,3 @@ class SkylineParameter:
 
 def skyline_parameter(x: SkylineParameterLike) -> SkylineParameter:
     return SkylineParameter(x) if isinstance(x, pgt.Scalar) else x
-
-
-def is_skyline_parameter_like(x: object) -> TypeGuard[SkylineParameterLike]:
-    return isinstance(x, pgt.Scalar | SkylineParameter)
-
-
-def is_many_skyline_parameters_like(
-    x: object,
-) -> TypeGuard[pgt.Many[SkylineParameterLike]]:
-    return tg.is_many(x) and all(is_skyline_parameter_like(v) for v in x)