replace setters with setParam for all Number, otherwise type mismatch…

… err #478
LinguaPhylo · Aug 7, 2024 · c068967 · c068967
1 parent a5f3f1d
commit c068967
Show file tree

Hide file tree

Showing 15 changed files with 206 additions and 31 deletions.
diff --git a/lphy-base/src/main/java/lphy/base/distribution/Bernoulli.java b/lphy-base/src/main/java/lphy/base/distribution/Bernoulli.java
@@ -47,8 +47,15 @@ public Map<String,Value> getParams() {
         return Collections.singletonMap(pParamName, p);
     }
 
-    public void setP(Double p) {
-        this.p.setValue(p);
-    }
+    /**
+     * Cannot use setters because of Number
+     */
+
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(pParamName)) p = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
 
+        super.setParam(paramName, value); // constructDistribution
+    }
 }
diff --git a/lphy-base/src/main/java/lphy/base/distribution/Beta.java b/lphy-base/src/main/java/lphy/base/distribution/Beta.java
@@ -68,6 +68,19 @@ public Map<String, Value> getParams() {
         }};
     }
 
+    /**
+     * Cannot use setters because of Number
+     */
+
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(alphaParamName)) alpha = value;
+        else if (paramName.equals(betaParamName)) beta = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
+
+        super.setParam(paramName, value); // constructDistribution
+    }
+
     private static final Double[] domainBounds = {0.0, 1.0};
 
     public Double[] getDomainBounds() {

diff --git a/lphy-base/src/main/java/lphy/base/distribution/Cauchy.java b/lphy-base/src/main/java/lphy/base/distribution/Cauchy.java
@@ -12,6 +12,9 @@
 import java.util.Map;
 import java.util.TreeMap;
 
+import static lphy.base.distribution.DistributionConstants.medianParamName;
+import static lphy.base.distribution.DistributionConstants.scaleParamName;
+
 /**
  * Cauchy distribution.
  * @see CauchyDistribution
@@ -26,7 +29,7 @@ public class Cauchy extends ParametricDistribution<Double> {
     CauchyDistribution cauchyDistribution;
 
     public Cauchy(@ParameterInfo(name = DistributionConstants.medianParamName, description = "the median of the Cauchy distribution.") Value<Number> median,
-                  @ParameterInfo(name = DistributionConstants.scaleParamName, description = "the scale of the Cauchy distribution.") Value<Number> scale) {
+                  @ParameterInfo(name = scaleParamName, description = "the scale of the Cauchy distribution.") Value<Number> scale) {
         super();
         this.median = median;
         this.scale = scale;
@@ -58,8 +61,16 @@ public double density(Double x) {
     public Map<String, Value> getParams() {
         return new TreeMap<>() {{
             put(DistributionConstants.medianParamName, median);
-            put(DistributionConstants.scaleParamName, scale);
+            put(scaleParamName, scale);
         }};
     }
 
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(medianParamName)) median = value;
+        else if (paramName.equals(scaleParamName)) scale = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
+
+        super.setParam(paramName, value); // constructDistribution
+    }
 }
diff --git a/lphy-base/src/main/java/lphy/base/distribution/Dirichlet.java b/lphy-base/src/main/java/lphy/base/distribution/Dirichlet.java
@@ -22,7 +22,8 @@ public class Dirichlet extends ParametricDistribution<Double[]> {
 
     private Value<Number[]> concentration;
 
-    public Dirichlet(@ParameterInfo(name=concParamName, narrativeName = "concentration", description="the concentration parameters of a Dirichlet distribution.") Value<Number[]> concentration) {
+    public Dirichlet(@ParameterInfo(name=concParamName, narrativeName = "concentration",
+            description="the concentration parameters of a Dirichlet distribution.") Value<Number[]> concentration) {
         super();
         this.concentration = concentration;
     }
@@ -60,6 +61,14 @@ public Map<String,Value> getParams() {
         return Collections.singletonMap(concParamName, concentration);
     }
 
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(concParamName)) concentration = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
+
+        super.setParam(paramName, value); // constructDistribution
+    }
+
     public Value<Number[]> getConcentration() {
         return concentration;
     }

diff --git a/lphy-base/src/main/java/lphy/base/distribution/DiscretizedGamma.java b/lphy-base/src/main/java/lphy/base/distribution/DiscretizedGamma.java
@@ -77,6 +77,15 @@ public Map<String, Value> getParams() {
         }};
     }
 
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(shapeParamName)) shape = value;
+        else if (paramName.equals(ncatParamName)) ncat = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
+
+        super.setParam(paramName, value); // constructDistribution
+    }
+
     public Value<Number> getShape() {
         return shape;
     }

diff --git a/lphy-base/src/main/java/lphy/base/distribution/Exp.java b/lphy-base/src/main/java/lphy/base/distribution/Exp.java
@@ -13,6 +13,8 @@
 import java.util.Collections;
 import java.util.Map;
 
+import static lphy.base.distribution.DistributionConstants.meanParamName;
+
 /**
  * Exponential distribution prior.
  * @see ExponentialDistribution
@@ -25,7 +27,7 @@ public class Exp extends ParametricDistribution<Double> implements GenerativeDis
 
     ExponentialDistribution exp;
 
-    public Exp(@ParameterInfo(name= DistributionConstants.meanParamName,
+    public Exp(@ParameterInfo(name= meanParamName,
             description="the mean of an exponential distribution.") Value<Number> mean) {
         super();
         this.mean = mean;
@@ -56,7 +58,15 @@ public double density(Double aDouble) {
 
     @Override
     public Map<String,Value> getParams() {
-        return Collections.singletonMap(DistributionConstants.meanParamName, mean);
+        return Collections.singletonMap(meanParamName, mean);
+    }
+
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(meanParamName)) mean = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
+
+        super.setParam(paramName, value); // constructDistribution
     }
 
     @Override
@@ -69,9 +79,10 @@ public double getMean() {
         return 1.0;
     }
 
-    public void setMean(double mean) {
-        this.mean.setValue(mean);
-        constructDistribution(random);
-    }
+    //TODO this works strangely. When Value<Number> mean = 1, the mean.value is double 1.0
+//    public void setMean(double mean) {
+//        this.mean.setValue(mean);
+//        constructDistribution(random);
+//    }
 
 }
diff --git a/lphy-base/src/main/java/lphy/base/distribution/Gamma.java b/lphy-base/src/main/java/lphy/base/distribution/Gamma.java
@@ -71,6 +71,15 @@ public Map<String, Value> getParams() {
         }};
     }
 
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(shapeParamName)) shape = value;
+        else if (paramName.equals(scaleParamName)) scale = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
+
+        super.setParam(paramName, value); // constructDistribution
+    }
+
     public Value<Number> getScale() {
         return scale;
     }

diff --git a/lphy-base/src/main/java/lphy/base/distribution/InverseGamma.java b/lphy-base/src/main/java/lphy/base/distribution/InverseGamma.java
@@ -13,6 +13,9 @@
 import java.util.Map;
 import java.util.TreeMap;
 
+import static lphy.base.distribution.DistributionConstants.alphaParamName;
+import static lphy.base.distribution.DistributionConstants.betaParamName;
+
 /**
  * Inverse-gamma distribution.
  * @see GammaDistribution
@@ -26,7 +29,7 @@ public class InverseGamma extends ParametricDistribution<Double> implements Gene
 
     GammaDistribution gammaDistribution;
 
-    public InverseGamma(@ParameterInfo(name = DistributionConstants.alphaParamName, description = "the alpha parameter of inverse gamma.") Value<Number> alpha,
+    public InverseGamma(@ParameterInfo(name = alphaParamName, description = "the alpha parameter of inverse gamma.") Value<Number> alpha,
                         @ParameterInfo(name = DistributionConstants.betaParamName, description = "the beta parameter of inverse gamma.") Value<Number> beta) {
         super();
         this.alpha = alpha;
@@ -37,7 +40,7 @@ public InverseGamma(@ParameterInfo(name = DistributionConstants.alphaParamName,
 
     @Override
     protected void constructDistribution(RandomGenerator random) {
-        if (alpha == null) throw new IllegalArgumentException("The " + DistributionConstants.alphaParamName + " value can't be null!");
+        if (alpha == null) throw new IllegalArgumentException("The " + alphaParamName + " value can't be null!");
         if (beta == null) throw new IllegalArgumentException("The " + DistributionConstants.betaParamName + " value can't be null!");
 
         double a = ValueUtils.doubleValue(alpha);
@@ -62,11 +65,20 @@ public double density(Double x) {
 
     public Map<String, Value> getParams() {
         return new TreeMap<>() {{
-            put(DistributionConstants.alphaParamName, alpha);
+            put(alphaParamName, alpha);
             put(DistributionConstants.betaParamName, beta);
         }};
     }
 
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(alphaParamName)) alpha = value;
+        else if (paramName.equals(betaParamName)) beta = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
+
+        super.setParam(paramName, value); // constructDistribution
+    }
+
     public Value<Number> getBeta() {
         return beta;
     }

diff --git a/lphy-base/src/main/java/lphy/base/distribution/LogNormal.java b/lphy-base/src/main/java/lphy/base/distribution/LogNormal.java
@@ -13,6 +13,8 @@
 import java.util.Map;
 import java.util.TreeMap;
 
+import static lphy.base.distribution.DistributionConstants.offsetParamName;
+
 /**
  * log-normal prior.
  * @see LogNormalDistribution
@@ -31,7 +33,7 @@ public class LogNormal extends ParametricDistribution<Double> implements Generat
 
     public LogNormal(@ParameterInfo(name = meanLogParamName, narrativeName = "mean in log space", description = "the mean of the distribution on the log scale.") Value<Number> M,
                      @ParameterInfo(name = sdLogParamName, narrativeName = "standard deviation in log space", description = "the standard deviation of the distribution on the log scale.") Value<Number> S,
-                     @ParameterInfo(name = DistributionConstants.offsetParamName, optional = true, narrativeName = "offset", description = "optional parameter to shift entire distribution by an offset. default is 0.") Value<Number> offset) {
+                     @ParameterInfo(name = offsetParamName, optional = true, narrativeName = "offset", description = "optional parameter to shift entire distribution by an offset. default is 0.") Value<Number> offset) {
         super();
         this.M = M;
         this.S = S;
@@ -75,9 +77,20 @@ public Map<String, Value> getParams() {
         return new TreeMap<>() {{
             put(meanLogParamName, M);
             put(sdLogParamName, S);
+            if (offset != null) put(offsetParamName, offset);
         }};
     }
 
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(meanLogParamName)) M = value;
+        else if (paramName.equals(sdLogParamName)) S = value;
+        else if (paramName.equals(offsetParamName)) offset = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
+
+        super.setParam(paramName, value); // constructDistribution
+    }
+
     public Value<Number> getMeanLog() {
         return M;
     }

diff --git a/lphy-base/src/main/java/lphy/base/distribution/NormalGamma.java b/lphy-base/src/main/java/lphy/base/distribution/NormalGamma.java
@@ -13,6 +13,8 @@
 import java.util.Map;
 import java.util.TreeMap;
 
+import static lphy.base.distribution.DistributionConstants.*;
+
 /**
  * Normal-gamma distribution
  */
@@ -28,8 +30,8 @@ public class NormalGamma extends ParametricDistribution<Double[]> {
 
     static final String precisionParamName = "precision";
 
-    public NormalGamma(@ParameterInfo(name = DistributionConstants.shapeParamName, description = "the shape of the distribution.") Value<Number> shape,
-                       @ParameterInfo(name = DistributionConstants.scaleParamName, description = "the scale of the distribution.") Value<Number> scale,
+    public NormalGamma(@ParameterInfo(name = shapeParamName, description = "the shape of the distribution.") Value<Number> shape,
+                       @ParameterInfo(name = scaleParamName, description = "the scale of the distribution.") Value<Number> scale,
                        @ParameterInfo(name = DistributionConstants.meanParamName, description = "the mean of the distribution.") Value<Number> mean,
                        @ParameterInfo(name = precisionParamName, narrativeName = "precision", description = "the standard deviation of the distribution.") Value<Number> precision) {
         super();
@@ -75,13 +77,24 @@ public double density(Double[] x) {
 
     public Map<String, Value> getParams() {
         return new TreeMap<>() {{
-            put(DistributionConstants.shapeParamName, shape);
-            put(DistributionConstants.scaleParamName, scale);
-            put(DistributionConstants.meanParamName, mean);
+            put(shapeParamName, shape);
+            put(scaleParamName, scale);
+            put(meanParamName, mean);
             put(precisionParamName, precision);
         }};
     }
 
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(shapeParamName)) shape = value;
+        else if (paramName.equals(scaleParamName)) scale = value;
+        else if (paramName.equals(meanParamName)) mean = value;
+        else if (paramName.equals(precisionParamName)) precision = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
+
+        super.setParam(paramName, value); // constructDistribution
+    }
+
     public Value<Number> getMean() {
         return mean;
     }

diff --git a/lphy-base/src/main/java/lphy/base/distribution/Poisson.java b/lphy-base/src/main/java/lphy/base/distribution/Poisson.java
@@ -14,6 +14,8 @@
 import java.util.Map;
 import java.util.TreeMap;
 
+import static lphy.base.distribution.DistributionConstants.offsetParamName;
+
 /**
  * The discrete probability distribution of
  * the number of events when the expected number of events is lambda.
@@ -36,7 +38,7 @@ public class Poisson extends ParametricDistribution<Integer> implements Generati
     static final int MAX_TRIES = 10000;
 
     public Poisson(@ParameterInfo(name=lambdaParamName, description="the expected number of events.") Value<Number> lambda,
-                   @ParameterInfo(name= DistributionConstants.offsetParamName, optional = true,
+                   @ParameterInfo(name= offsetParamName, optional = true,
                            description = "optional parameter to add a constant to the returned result, default is 0") Value<Integer> offset,
                    @ParameterInfo(name=minParamName, optional = true,
                            description = "optional parameter to specify a condition that the number of events " +
@@ -113,9 +115,25 @@ public Map<String,Value> getParams() {
             put(lambdaParamName, lambda);
             if (min != null) put(minParamName, min);
             if (max != null) put(maxParamName, max);
-            if (offset != null) put(DistributionConstants.offsetParamName, offset);
+            if (offset != null) put(offsetParamName, offset);
         }};    }
 
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(lambdaParamName)) lambda = value;
+        else if (paramName.equals(minParamName)) min = value;
+        else if (paramName.equals(maxParamName)) max = value;
+        else if (paramName.equals(offsetParamName)) offset = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
+
+        super.setParam(paramName, value); // constructDistribution
+    }
+
+//    public void setLambda(double p) {
+//        this.lambda.setValue(p);
+//        constructDistribution(random);
+//    }
+
     public void setLambda(double p) {
         this.lambda.setValue(p);
         constructDistribution(random);

diff --git a/lphy-base/src/main/java/lphy/base/distribution/Uniform.java b/lphy-base/src/main/java/lphy/base/distribution/Uniform.java
@@ -12,6 +12,9 @@
 import java.util.Map;
 import java.util.TreeMap;
 
+import static lphy.base.distribution.DistributionConstants.lowerParamName;
+import static lphy.base.distribution.DistributionConstants.upperParamName;
+
 /**
  * Created by Alexei Drummond on 18/12/19.
  */
@@ -62,6 +65,15 @@ public Map<String, Value> getParams() {
         }};
     }
 
+    @Override
+    public void setParam(String paramName, Value value) {
+        if (paramName.equals(lowerParamName)) lower = value;
+        else if (paramName.equals(upperParamName)) upper = value;
+        else throw new RuntimeException("Unrecognised parameter name: " + paramName);
+
+        super.setParam(paramName, value); // constructDistribution
+    }
+
     private static final Double[] domainBounds = {Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY};
     @Override
     public Double[] getDomainBounds() {