make GeneticValueToFitnessMap a pure ABC on the C++ side (#1375)

molpopgen · web-flow · commit be5aee028248 · 2025-04-09T13:57:30.000-07:00
diff --git a/cpp/genetic_value_to_fitness/GeneticValueIsFitness.cc b/cpp/genetic_value_to_fitness/GeneticValueIsFitness.cc
@@ -11,7 +11,7 @@ init_GeneticValueIsFitness(py::module& m)
         .def(py::init<std::size_t>())
         .def(py::pickle(
             [](const fwdpy11::GeneticValueIsFitness& g) {
-                return py::make_tuple(g.total_dim);
+                return py::make_tuple(g.ndim());
             },
             [](py::tuple t) {
                 std::size_t ndim = t[0].cast<std::size_t>();
diff --git a/cpp/genetic_value_to_fitness/GeneticValueToFitnessMap.cc b/cpp/genetic_value_to_fitness/GeneticValueToFitnessMap.cc
@@ -12,7 +12,7 @@ init_GeneticValueToFitnessMap(py::module& m)
         .def_property_readonly(
             "shape",
             [](const fwdpy11::GeneticValueToFitnessMap& self) {
-                return pybind11::make_tuple(self.total_dim);
+                return pybind11::make_tuple(self.ndim());
             },
             R"delim(
         Returns the shape (dimensonality) of the object
@@ -21,7 +21,9 @@ init_GeneticValueToFitnessMap(py::module& m)
         )delim")
         .def_property_readonly(
             "maps_to_fitness",
-            [](const fwdpy11::GeneticValueToFitnessMap& self) { return self.isfitness; },
+            [](const fwdpy11::GeneticValueToFitnessMap& self) {
+                return self.is_fitness();
+            },
             R"delim(
         Returns True if object represents a mapping directly to fitness, and
         False otherwise.
@@ -31,7 +33,7 @@ init_GeneticValueToFitnessMap(py::module& m)
         .def_property_readonly(
             "maps_to_trait_value",
             [](const fwdpy11::GeneticValueToFitnessMap& self) {
-                return !self.isfitness;
+                return !self.is_fitness();
             },
             R"delim(
         Returns True if object represents a trait value, and
@@ -40,4 +42,3 @@ init_GeneticValueToFitnessMap(py::module& m)
         .. versionadded:: 0.7.0
         )delim");
 }
-
diff --git a/cpp/genetic_values/DiploidGeneticValue.cc b/cpp/genetic_values/DiploidGeneticValue.cc
@@ -42,7 +42,7 @@ init_DiploidGeneticValue(py::module& m)
         .def_property_readonly(
             "maps_to_fitness",
             [](const fwdpy11::DiploidGeneticValue& self) {
-                return self.gv2w->isfitness;
+                return self.gv2w->is_fitness();
             },
             R"delim(
         Returns True if object represents a mapping directly to fitness, and
@@ -53,7 +53,7 @@ init_DiploidGeneticValue(py::module& m)
         .def_property_readonly(
             "maps_to_trait_value",
             [](const fwdpy11::DiploidGeneticValue& self) {
-                return !self.gv2w->isfitness;
+                return !self.gv2w->is_fitness();
             },
             R"delim(
         Returns True if object represents a trait value, and
diff --git a/fwdpy11/headers/fwdpy11/genetic_value_to_fitness/GaussianStabilizingSelection.hpp b/fwdpy11/headers/fwdpy11/genetic_value_to_fitness/GaussianStabilizingSelection.hpp
@@ -15,17 +15,18 @@ namespace fwdpy11
 
       public:
         explicit GaussianStabilizingSelection(const GSSmo &input)
-            : GeneticValueIsTrait(input.total_dim), pimpl(input.clone())
+            : GeneticValueIsTrait(input.ndim()), pimpl(input.clone())
         {
         }
 
         explicit GaussianStabilizingSelection(const MultivariateGSSmo &input)
-            : GeneticValueIsTrait(input.total_dim), pimpl(input.clone())
+            : GeneticValueIsTrait(input.ndim()), pimpl(input.clone())
         {
         }
 
         double
-        operator()(const DiploidGeneticValueToFitnessData data) const final {
+        operator()(const DiploidGeneticValueToFitnessData data) const final
+        {
             return this->pimpl->operator()(data);
         }
 
diff --git a/fwdpy11/headers/fwdpy11/genetic_value_to_fitness/GeneticValueIsFitness.hpp b/fwdpy11/headers/fwdpy11/genetic_value_to_fitness/GeneticValueIsFitness.hpp
@@ -24,10 +24,14 @@
 
 namespace fwdpy11
 {
-    struct GeneticValueIsFitness : public GeneticValueToFitnessMap
+    class GeneticValueIsFitness : public GeneticValueToFitnessMap
     {
+      private:
+        std::size_t dim;
+
+      public:
         explicit GeneticValueIsFitness(std::size_t ndim)
-            : GeneticValueToFitnessMap(ndim, maps_to_fitness(true))
+            : GeneticValueToFitnessMap(), dim(ndim)
         {
         }
 
@@ -45,7 +49,17 @@ namespace fwdpy11
         std::shared_ptr<GeneticValueToFitnessMap>
         clone() const override
         {
-            return std::make_shared<GeneticValueIsFitness>(this->total_dim);
+            return std::make_shared<GeneticValueIsFitness>(this->dim);
+        }
+
+        std::size_t
+        ndim() const override
+        {
+            return this->dim;
+        }
+
+        bool is_fitness() const override {
+            return true;
         }
     };
 } // namespace fwdpy11
diff --git a/fwdpy11/headers/fwdpy11/genetic_value_to_fitness/GeneticValueIsTrait.hpp b/fwdpy11/headers/fwdpy11/genetic_value_to_fitness/GeneticValueIsTrait.hpp
@@ -24,18 +24,33 @@
 
 namespace fwdpy11
 {
-    struct GeneticValueIsTrait : public GeneticValueToFitnessMap
+    class GeneticValueIsTrait : public GeneticValueToFitnessMap
     /// Another ABC.  Effectively a type trait
     {
+      private:
+        std::size_t dim;
+
+      public:
         explicit GeneticValueIsTrait(std::size_t ndim)
-            : GeneticValueToFitnessMap(ndim, maps_to_fitness(false))
+            : GeneticValueToFitnessMap(), dim(ndim)
         {
         }
         virtual ~GeneticValueIsTrait() = default;
         GeneticValueIsTrait(const GeneticValueIsTrait&) = delete;
         GeneticValueIsTrait(GeneticValueIsTrait&&) = default;
         GeneticValueIsTrait& operator=(const GeneticValueIsTrait&) = delete;
         GeneticValueIsTrait& operator=(GeneticValueIsTrait&&) = default;
+        std::size_t
+        ndim() const override
+        {
+            return this->dim;
+        }
+
+        bool
+        is_fitness() const override
+        {
+            return false;
+        }
     };
 } // namespace fwdpy11
 
diff --git a/fwdpy11/headers/fwdpy11/genetic_value_to_fitness/GeneticValueToFitnessMap.hpp b/fwdpy11/headers/fwdpy11/genetic_value_to_fitness/GeneticValueToFitnessMap.hpp
@@ -21,25 +21,13 @@
 
 #include <memory>
 #include <fwdpy11/types/DiploidPopulation.hpp>
-#include <fwdpy11/genetic_values/default_update.hpp>
-#include <fwdpp/util/named_type.hpp>
 #include <fwdpy11/genetic_value_data/genetic_value_data.hpp>
 
 namespace fwdpy11
 {
-    struct genetic_value_maps_to_fitness
-    {
-    };
-
-    using maps_to_fitness
-        = fwdpp::strong_types::named_type<bool, genetic_value_maps_to_fitness>;
-
     struct GeneticValueToFitnessMap
     {
-        std::size_t total_dim;
-        bool isfitness;
-        explicit GeneticValueToFitnessMap(std::size_t ndim, const maps_to_fitness& m)
-            : total_dim{ndim}, isfitness{m.get()}
+        GeneticValueToFitnessMap()
         {
         }
 
@@ -49,10 +37,12 @@ namespace fwdpy11
         GeneticValueToFitnessMap& operator=(const GeneticValueToFitnessMap&) = delete;
         GeneticValueToFitnessMap& operator=(GeneticValueToFitnessMap&&) = default;
 
-        virtual double
-        operator()(const DiploidGeneticValueToFitnessData /*data*/) const = 0;
+        virtual double operator()(const DiploidGeneticValueToFitnessData /*data*/) const
+            = 0;
         virtual void update(const DiploidPopulation& /*pop*/) = 0;
         virtual std::shared_ptr<GeneticValueToFitnessMap> clone() const = 0;
+        virtual bool is_fitness() const = 0;
+        virtual std::size_t ndim() const = 0;
     };
 } //namespace fwdpy11
 
diff --git a/fwdpy11/headers/fwdpy11/genetic_value_to_fitness/MultivariateGSSmo.hpp b/fwdpy11/headers/fwdpy11/genetic_value_to_fitness/MultivariateGSSmo.hpp
@@ -39,8 +39,8 @@ namespace fwdpy11
 
         MultivariateGSSmo(const std::vector<PleiotropicOptima> &po)
             : GeneticValueIsTrait{po.empty() ? 0 : po[0].optima.size()}, optima(po),
-              current_timepoint(0),
-              current_timepoint_optima{}, VW{std::numeric_limits<double>::quiet_NaN()}
+              current_timepoint(0), current_timepoint_optima{},
+              VW{std::numeric_limits<double>::quiet_NaN()}
         {
             if (po.empty())
                 {
@@ -54,9 +54,10 @@ namespace fwdpy11
                                 "invalid when value for PleiotropicOptima");
                         }
                 }
+            auto x = po[0].optima.size();
             for (auto &o : optima)
                 {
-                    if (o.optima.size() != total_dim)
+                    if (o.optima.size() != x)
                         {
                             throw std::invalid_argument(
                                 "all lists of optima must be the same length");
@@ -71,7 +72,7 @@ namespace fwdpy11
         double
         operator()(const DiploidGeneticValueToFitnessData data) const override
         {
-            if (data.gvalues.get().size() != total_dim)
+            if (data.gvalues.get().size() != optima[0].optima.size())
                 {
                     throw std::runtime_error("dimension mismatch");
                 }
@@ -115,8 +116,13 @@ namespace fwdpy11
         {
             update_details(pop);
         }
+
+        std::size_t
+        ndim() const
+        {
+            return optima[0].optima.size();
+        }
     };
 } // namespace fwdpy11
 
 #endif
-
diff --git a/fwdpy11/headers/fwdpy11/genetic_values/fwdpp_wrappers/fwdpp_genetic_value.hpp b/fwdpy11/headers/fwdpy11/genetic_values/fwdpp_wrappers/fwdpp_genetic_value.hpp
@@ -104,7 +104,7 @@ namespace fwdpy11
             const GeneticValueNoise* noise_)
             : DiploidGeneticValue{ndim, gv2w_, noise_}, gv{clamp}, aa_scaling(scaling),
               make_return_value(std::move(mrv)),
-              callback(init_callback(ndim, aa_scaling)), isfitness(gv2w->isfitness)
+              callback(init_callback(ndim, aa_scaling)), isfitness(gv2w->is_fitness())
         {
         }
 

Original file line number	Diff line number	Diff line change
`@@ -15,17 +15,18 @@ namespace fwdpy11`
`15`	`15`
`16`	`16`	`public:`
`17`	`17`	`explicit GaussianStabilizingSelection(const GSSmo &input)`
`18`		`- : GeneticValueIsTrait(input.total_dim), pimpl(input.clone())`
	`18`	`+ : GeneticValueIsTrait(input.ndim()), pimpl(input.clone())`
`19`	`19`	`{`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`explicit GaussianStabilizingSelection(const MultivariateGSSmo &input)`
`23`		`- : GeneticValueIsTrait(input.total_dim), pimpl(input.clone())`
	`23`	`+ : GeneticValueIsTrait(input.ndim()), pimpl(input.clone())`
`24`	`24`	`{`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`double`
`28`		`- operator()(const DiploidGeneticValueToFitnessData data) const final {`
	`28`	`+ operator()(const DiploidGeneticValueToFitnessData data) const final`
	`29`	`+ {`
`29`	`30`	`return this->pimpl->operator()(data);`
`30`	`31`	`}`
`31`	`32`
Original file line number	Diff line number	Diff line change
`@@ -24,10 +24,14 @@`
`24`	`24`
`25`	`25`	`namespace fwdpy11`
`26`	`26`	`{`
`27`		`- struct GeneticValueIsFitness : public GeneticValueToFitnessMap`
	`27`	`+ class GeneticValueIsFitness : public GeneticValueToFitnessMap`
`28`	`28`	`{`
	`29`	`+ private:`
	`30`	`+ std::size_t dim;`
	`31`	`+`
	`32`	`+ public:`
`29`	`33`	`explicit GeneticValueIsFitness(std::size_t ndim)`
`30`		`- : GeneticValueToFitnessMap(ndim, maps_to_fitness(true))`
	`34`	`+ : GeneticValueToFitnessMap(), dim(ndim)`
`31`	`35`	`{`
`32`	`36`	`}`
`33`	`37`
`@@ -45,7 +49,17 @@ namespace fwdpy11`
`45`	`49`	`std::shared_ptr<GeneticValueToFitnessMap>`
`46`	`50`	`clone() const override`
`47`	`51`	`{`
`48`		`- return std::make_shared<GeneticValueIsFitness>(this->total_dim);`
	`52`	`+ return std::make_shared<GeneticValueIsFitness>(this->dim);`
	`53`	`+ }`
	`54`	`+`
	`55`	`+ std::size_t`
	`56`	`+ ndim() const override`
	`57`	`+ {`
	`58`	`+ return this->dim;`
	`59`	`+ }`
	`60`	`+`
	`61`	`+ bool is_fitness() const override {`
	`62`	`+ return true;`
`49`	`63`	`}`
`50`	`64`	`};`
`51`	`65`	`} // namespace fwdpy11`
Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,8 @@ namespace fwdpy11`
`39`	`39`
`40`	`40`	`MultivariateGSSmo(const std::vector<PleiotropicOptima> &po)`
`41`	`41`	`: GeneticValueIsTrait{po.empty() ? 0 : po[0].optima.size()}, optima(po),`
`42`		`- current_timepoint(0),`
`43`		`- current_timepoint_optima{}, VW{std::numeric_limits<double>::quiet_NaN()}`
	`42`	`+ current_timepoint(0), current_timepoint_optima{},`
	`43`	`+ VW{std::numeric_limits<double>::quiet_NaN()}`
`44`	`44`	`{`
`45`	`45`	`if (po.empty())`
`46`	`46`	`{`
`@@ -54,9 +54,10 @@ namespace fwdpy11`
`54`	`54`	`"invalid when value for PleiotropicOptima");`
`55`	`55`	`}`
`56`	`56`	`}`
	`57`	`+ auto x = po[0].optima.size();`
`57`	`58`	`for (auto &o : optima)`
`58`	`59`	`{`
`59`		`- if (o.optima.size() != total_dim)`
	`60`	`+ if (o.optima.size() != x)`
`60`	`61`	`{`
`61`	`62`	`throw std::invalid_argument(`
`62`	`63`	`"all lists of optima must be the same length");`
`@@ -71,7 +72,7 @@ namespace fwdpy11`
`71`	`72`	`double`
`72`	`73`	`operator()(const DiploidGeneticValueToFitnessData data) const override`
`73`	`74`	`{`
`74`		`- if (data.gvalues.get().size() != total_dim)`
	`75`	`+ if (data.gvalues.get().size() != optima[0].optima.size())`
`75`	`76`	`{`
`76`	`77`	`throw std::runtime_error("dimension mismatch");`
`77`	`78`	`}`
`@@ -115,8 +116,13 @@ namespace fwdpy11`
`115`	`116`	`{`
`116`	`117`	`update_details(pop);`
`117`	`118`	`}`
	`119`	`+`
	`120`	`+ std::size_t`
	`121`	`+ ndim() const`
	`122`	`+ {`
	`123`	`+ return optima[0].optima.size();`
	`124`	`+ }`
`118`	`125`	`};`
`119`	`126`	`} // namespace fwdpy11`
`120`	`127`
`121`	`128`	`#endif`
`122`		`-`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ namespace fwdpy11`
`104`	`104`	`const GeneticValueNoise* noise_)`
`105`	`105`	`: DiploidGeneticValue{ndim, gv2w_, noise_}, gv{clamp}, aa_scaling(scaling),`
`106`	`106`	`make_return_value(std::move(mrv)),`
`107`		`- callback(init_callback(ndim, aa_scaling)), isfitness(gv2w->isfitness)`
	`107`	`+ callback(init_callback(ndim, aa_scaling)), isfitness(gv2w->is_fitness())`
`108`	`108`	`{`
`109`	`109`	`}`
`110`	`110`