configurable random seed & better validation (#2)

Author: tohtsky

App.vue

@@ -48,6 +48,12 @@ canvas {
                           <v-text-field label="Number of samples" type="Number" v-model.number="nSamples"
                             :error-messages="nSamplesError"></v-text-field>
                         </v-col>
+                        <v-col cols="6">
+                          <v-text-field label="Random seed" type="Number" v-model.number="randomSeed"
+                            :error-messages="randomSeedError"></v-text-field>
+                        </v-col>
+
+
                       </v-row>
                     </v-card-text>
                   </v-card>
@@ -86,6 +92,8 @@ canvas {
 import { compute } from "./bayesian-wasm/pkg";
 import Group from "./components/Group.vue";
 
+
+
 export default {
   data() {
     return {
@@ -105,6 +113,8 @@ export default {
       betaError: [],
       nSamples: 100000,
       nSamplesError: [],
+      randomSeed: 0,
+      randomSeedError: [],
       n_bins: 100,
       result: null,
       dpr: 3,
@@ -117,25 +127,36 @@ export default {
       if (this.b === null) invalid = true;
       let alpha = parseFloat(this.alpha);
       let beta = parseFloat(this.beta);
-      let nSamples = parseInt(this.nSamples);
-      if (isNaN(alpha) || alpha < 0) {
-        this.alphaError = ["valid, positive float required."];
+      let nSamples = parseFloat(this.nSamples, 10);
+      let randomSeed = parseFloat(this.randomSeed, 10);
+      if (isNaN(alpha) || alpha <= 0) {
+        this.alphaError = ["valid, positive floating number required."];
         invalid = true;
       } else {
         this.alphaError = null;
       }
-      if (isNaN(beta) || beta < 0) {
-        this.betaError = ["valid, positive float required."];
+      if (isNaN(beta) || beta <= 0) {
+        this.betaError = ["valid, positive floating number required."];
         invalid = true;
       } else {
         this.betaError = [];
       }
-      if (isNaN(nSamples) || nSamples <= 0) {
-        this.nSamplesError = ["this field must be strictly positive."];
+      if (isNaN(nSamples) || nSamples <= 0 || !Number.isInteger(nSamples)) {
+        this.nSamplesError = ["This field must be a strictly positive integer."];
         invalid = true;
       } else {
         this.nSamplesError = [];
       }
+
+
+      if (isNaN(randomSeed) || randomSeed < 0 || !Number.isInteger(randomSeed)) {
+        this.randomSeedError = ["This field must be a non-negative integer."];
+        invalid = true;
+      } else {
+        this.randomSeedError = [];
+      }
+
+
       if (invalid) {
         return null;
       }
@@ -149,6 +170,7 @@ export default {
         b_pos: this.b.pos,
         n_samples: nSamples,
         n_bins: this.n_bins,
+        random_seed: randomSeed,
       };
       return JSON.stringify(data);
     },

bayesian-wasm/src/bbinomial.rs

@@ -16,6 +16,14 @@ fn _take_f64(v: &Value, key: &str) -> Result<f64, JsValue> {
     }
 }
 
+fn _take_u64(v: &Value, key: &str) -> Result<u64, JsValue> {
+    let target = &v[key];
+    match target.as_u64() {
+        Some(value) => Ok(value),
+        None => Err(JsValue::from_str(key)),
+    }
+}
+
 fn _take_f64_arr(v: &Value, key: &str) -> Result<Vec<f64>, JsValue> {
     let target = &v[key];
     let mut result = Vec::new();
@@ -68,7 +76,6 @@ pub fn compute(
     let dpr_i = dpr as i32;
 
     use serde_json;
-    let mut rng = Pcg64::seed_from_u64(0 as u64);
     let parsed: Value = match serde_json::from_str(target) {
         Ok(v) => Ok(v),
         Err(_) => Err(JsValue::from_str("Invalid JSON!")),
@@ -92,13 +99,16 @@ pub fn compute(
         Err(_) => 1.0,
     };
 
-    let n_samples = match _take_f64(&parsed, "n_samples") {
-        Ok(f) => f as i64,
-        Err(_) => 1000,
+    let n_samples = match _take_u64(&parsed, "n_samples") {
+        Ok(f) => f,
+        Err(_) => 1000 as u64,
     };
-    if n_samples <= 0 {
-        return Err(JsValue::from_str("n_samples must be strictly positive!"));
-    }
+
+    let random_seed = match _take_u64(&parsed, "random_seed") {
+        Ok(f) => f,
+        Err(_) => 0 as u64,
+    };
+
     let n_bins = match _take_f64(&parsed, "n_bins") {
         Ok(f) => f as i64,
         Err(_) => 100,
@@ -114,6 +124,8 @@ pub fn compute(
         ],
     };
 
+    let mut rng = Pcg64::seed_from_u64(random_seed);
+
     let dist_a = Beta::new(prior_pos + a_pos, prior_neg + a_tot - a_pos).unwrap();
     let dist_b = Beta::new(prior_pos + b_pos, prior_neg + b_tot - b_pos).unwrap();
     let mut a_samples = Vec::new();