Initialize hemisphere particle filters on the manifold

src/pyrecest/filters/hyperhemisphere_cart_prod_particle_filter.py

@@ -4,7 +4,7 @@
 from beartype import beartype
 
 # pylint: disable=no-name-in-module,no-member
-from pyrecest.backend import empty, ones, ones_like
+from pyrecest.backend import hstack, ones, ones_like, zeros
 from pyrecest.distributions import AbstractHypersphericalDistribution
 from pyrecest.distributions.cart_prod.hyperhemisphere_cart_prod_dirac_distribution import (
     HyperhemisphereCartProdDiracDistribution,
@@ -45,8 +45,15 @@ def __init__(
         n_particles = _validate_positive_integer(n_particles, "n_particles")
         dim_hemisphere = _validate_positive_integer(dim_hemisphere, "dim_hemisphere")
         n_hemispheres = _validate_positive_integer(n_hemispheres, "n_hemispheres")
+        initial_component = hstack(
+            (
+                zeros((n_particles, dim_hemisphere)),
+                ones((n_particles, 1)),
+            )
+        )
+        initial_particles = hstack([initial_component] * n_hemispheres)
         initial_filter_state = HyperhemisphereCartProdDiracDistribution(
-            empty((n_particles, (dim_hemisphere + 1) * n_hemispheres)),
+            initial_particles,
             ones(n_particles) / n_particles,
             dim_hemisphere,
             n_hemispheres,

src/pyrecest/filters/hyperhemispherical_particle_filter.py

@@ -1,6 +1,6 @@
 from numbers import Integral
 
-from pyrecest.backend import empty
+from pyrecest.backend import hstack, ones, zeros
 from pyrecest.distributions.hypersphere_subset.abstract_hyperhemispherical_distribution import (
     AbstractHyperhemisphericalDistribution,
 )
@@ -34,9 +34,10 @@ def __init__(self, n_particles: int, dim: int) -> None:
         """
         n_particles = _validate_positive_integer(n_particles, "n_particles")
         dim = _validate_positive_integer(dim, "dim")
-        initial_filter_state = HyperhemisphericalDiracDistribution(
-            empty((n_particles, dim + 1))
+        initial_particles = hstack(
+            (zeros((n_particles, dim)), ones((n_particles, 1)))
         )
+        initial_filter_state = HyperhemisphericalDiracDistribution(initial_particles)
         HyperhemisphericalFilterMixin.__init__(self)
         AbstractParticleFilter.__init__(self, initial_filter_state=initial_filter_state)
 

tests/filters/test_hyperhemisphere_cart_prod_particle_filter.py

@@ -3,8 +3,12 @@
 import pyrecest.backend  # pylint: disable=no-name-in-module,no-member
 from pyrecest.backend import (  # pylint: disable=no-name-in-module,no-member,redefined-builtin
     abs,
+    allclose,
     array,
+    hstack,
+    ones,
     sum,
+    zeros,
 )
 from pyrecest.distributions import VonMisesFisherDistribution
 from pyrecest.distributions.cart_prod.hyperhemisphere_cart_prod_dirac_distribution import (
@@ -27,6 +31,14 @@ def test_init(self):
             pf.filter_state.d.shape,
             (n_particles, (dim_hemisphere + 1) * n_hemispheres),
         )
+        expected_component = hstack(
+            (
+                zeros((n_particles, dim_hemisphere)),
+                ones((n_particles, 1)),
+            )
+        )
+        expected_particles = hstack([expected_component] * n_hemispheres)
+        self.assertTrue(bool(allclose(pf.filter_state.d, expected_particles)))
 
     def test_constructor_rejects_invalid_particle_count(self):
         for n_particles in (True, 0, -1, 1.5):

tests/filters/test_hyperhemispherical_particle_filter.py

@@ -4,7 +4,7 @@
 import pyrecest.backend
 
 # pylint: disable=redefined-builtin,no-name-in-module,no-member
-from pyrecest.backend import array, linalg, random
+from pyrecest.backend import allclose, array, hstack, linalg, ones, random, zeros
 from pyrecest.distributions import HyperhemisphericalWatsonDistribution
 from pyrecest.distributions.hypersphere_subset.hyperhemispherical_dirac_distribution import (
     HyperhemisphericalDiracDistribution,
@@ -32,6 +32,13 @@ def test_initialization(self):
         hpf = HyperhemisphericalParticleFilter(self.n_particles, 3)
         self.assertEqual(hpf.filter_state.w.shape, (self.n_particles,))
         self.assertEqual(hpf.filter_state.d.shape, (self.n_particles, 4))
+        expected_particles = hstack(
+            (
+                zeros((self.n_particles, 3)),
+                ones((self.n_particles, 1)),
+            )
+        )
+        self.assertTrue(bool(allclose(hpf.filter_state.d, expected_particles)))
 
     def test_constructor_rejects_invalid_particle_count(self):
         for n_particles in (True, 0, -1, 1.5):