Esempio n. 1
0
 /**
  * Metodo che carica i dati da un file B9. Carica i valori contenuti nella variabile e le valuta.
  *
  * @param path
  * @throws Exception
  */
 private static void loadData(String path) throws Exception {
   // si legge l'oggetto json
   BufferedReader reader = new BufferedReader(new FileReader(path));
   JSONParser parser = new JSONParser();
   JSONObject json = (JSONObject) parser.parse(reader.readLine());
   // si leggono le variabili
   JSONObject vars = (JSONObject) json.get("variables");
   JSONObject x_map = (JSONObject) json.get("x_map");
   JSONObject fitts = (JSONObject) json.get("fitters");
   project = (String) json.get("project");
   // si salva il percorso relativo
   B9_Main.path = path.substring(0, path.length() - (project.length() + 4));
   // si leggono le variabili
   for (Object u : vars.keySet()) {
     String id = (String) u;
     // si crea la variabile
     data.addVariable(id);
     Variable v = data.getVariable(id);
     JSONArray arr = (JSONArray) vars.get(id);
     for (Object mea : arr) {
       double m = (double) mea;
       // si aggiunge la misura
       v.addMeasure(m);
     }
     // si valuta la variabile
     v.evaluate();
     out.println("Loaded variable: " + id + " - N: " + v.getN());
   }
   // si leggono le x delle varibili
   for (Object m : x_map.keySet()) {
     String id = (String) m;
     // si aggiunge alla variabile la sua x
     double x = (double) x_map.get(m);
     data.addX_toVariable(id, x);
   }
   // si leggono i fitter
   for (Object f : fitts.keySet()) {
     String id = (String) f;
     // si crea la variabile
     fitter_man.addLinearFitter(id);
     LinearFitter fit = fitter_man.getLinearFitter(id);
     JSONArray arr = (JSONArray) fitts.get(id);
     for (Object v : arr) {
       String m = (String) v;
       // si aggiunge la misura
       VariableXY var = (VariableXY) data.getVariable(m);
       fit.addVariable(var);
     }
     out.println("Loaded fitter: " + id + " - N: " + fit.getN());
   }
   reader.close();
 }
Esempio n. 2
0
 /**
  * Metodo che salva i dati su disco. Si salvano in un unico file tutte le variabili.
  *
  * @throws IOException
  */
 @SuppressWarnings("unchecked")
 private static void saveData(String path, String name) throws IOException {
   // si crea un oggetto json
   JSONObject json = new JSONObject();
   json.put("project", name);
   LinkedHashMap<String, LinkedList<Double>> map_v = new LinkedHashMap<>();
   LinkedHashMap<String, Double> X_map = new LinkedHashMap<>();
   for (Variable v : data.getVariables().values()) {
     LinkedList<Double> ms = new LinkedList<>();
     for (double m : v.getMeasures()) {
       ms.add(m);
     }
     map_v.put(v.getId(), ms);
     // Se c'è la x si aggiunge
     if (v instanceof VariableXY) {
       X_map.put(v.getId(), ((VariableXY) v).getX());
     }
   }
   // mappa delle variabili
   json.put("variables", map_v);
   json.put("x_map", X_map);
   // si inseriscono i fitter
   LinkedHashMap<String, LinkedList<String>> map_f = new LinkedHashMap<>();
   for (LinearFitter v : fitter_man.getFitters().values()) {
     LinkedList<String> ms = new LinkedList<>();
     for (VariableXY va : v.getVariables().values()) {
       ms.add(va.getId());
     }
     map_f.put(v.getId(), ms);
   }
   // mappa dei fitter
   json.put("fitters", map_f);
   String path_touse;
   // scrittura su file
   if (path.equals("")) {
     path_touse = System.getProperty("user.home") + File.separator + name + ".b9";
   } else {
     path_touse = path + File.separator + name + ".b9";
   }
   // si scrive l'oggetto
   FileWriter w = new FileWriter(path_touse);
   w.write(json.toJSONString());
   w.close();
   out.println("Progetto salvato in: " + path_touse);
 }
Esempio n. 3
0
  /**
   * Ciclo dei comandi per il fitting.
   *
   * @throws IOException
   */
  private static void fit_cycle() throws IOException {
    boolean fit_cycle = true;
    while (fit_cycle) {
      out.print("fittin>> ");
      String cmd2 = in.readLine().trim();
      if (cmd2.equals("exit")) {
        fit_cycle = false;
        out.println("exit fit menu...\n");
        continue;
      }
      String[] p = cmd2.split(" ");
      // si stampano i fitters
      if (p[0].equals("fitters")) {
        for (LinearFitter fit : fitter_man.getFitters().values()) {
          out.print("\tID: " + fit.getId() + " - N: " + fit.getN());
          for (Variable v : fit.getVariables().values()) {
            out.print("\n\t\tVariable: " + v.getId() + " - N: " + v.getN());
          }
          out.println();
        }
        continue;
      }

      if (p.length < 2) {
        out.println("\tInserire nome del fitter\n");
        continue;
      }
      String f = p[1];
      try {
        // comandi
        switch (p[0]) {
          case "create":
            fitter_man.addLinearFitter(f);
            out.println("\tCreato fitter: " + f + "\n");
            break;
          case "add-variables":
            LinearFitter fitter = fitter_man.getLinearFitter(f);
            out.println("Inserire un id variabile e premere invio. (exit) per uscire...");
            // si inseriscono i valori
            boolean ok = true;
            int i = 1;
            while (ok) {
              out.print("\tvalue-" + f + "-" + i + ">> ");
              String s = in.readLine();
              if (s.equals("")) {
                continue;
              }
              if (s.equals("exit")) {
                ok = false;
                break;
              }
              if (data.containsVariable(s)) {
                Variable v = data.getVariable(s);
                if (v instanceof VariableXY) {
                  // si aggiunte
                  fitter.addVariable((VariableXY) v);
                } else {
                  out.println("Inserire una variabile di tipo XY...");
                }
              } else {
                out.println("Inserire un id variable valido...");
              }
              i++;
            }
            out.println();
            break;
          case "remove-variables":
            if (p.length < 3) {
              out.println(
                  "data>> Inserire parametri:\n" + " id fitter, variabile-xy da rimuovere\n");
              continue;
            }
            LinearFitter fitter1 = fitter_man.getLinearFitter(f);
            Variable v = data.getVariable(p[2]);
            if (v instanceof VariableXY) {
              double x = ((VariableXY) v).getX();
              fitter_man.removeVariableFromFitter(f, x);
              out.println("Rimossa variabile " + p[2] + " da fitter: " + f);
            } else {
              out.println("Inserire una variabile di tipo XY...");
            }
            break;
          case "remove-fitter":
            if (fitter_man.removeLinearFitter(f)) {

              out.println("Rimosso fitter: " + f);
            } else {
              out.println("Fitter non trovato: " + f);
            }
          case "fit-sigma-costant":
            // fitting con sigma per y costante
            // si legge il terzo parametro
            if (p.length < 3) {
              out.println(
                  "data>> Inserire parametri:\n" + " id fitter, sigma da utilizzare per le Y\n");
              continue;
            }
            double sigmay = Double.parseDouble(p[2]);
            // si effettua il fitting
            LinearFitter fitt = fitter_man.getLinearFitter(f);
            double[] e = fitt.fit_sigma_costant(sigmay);
            // si stampano i risultati
            out.println("A: ....................." + df.format(e[0]));
            out.println("B: ....................." + df.format(e[1]));
            out.println("Sigma-A: ..............." + df.format(e[2]));
            out.println("Sigma-B: ..............." + df.format(e[3]));
            out.println("Sigma-AB: .............." + df.format(e[4]));
            out.println();
            break;
          case "fit":
            // fittin pesato con i sigma delle variabili
            // si effettua il fitting
            LinearFitter fitte = fitter_man.getLinearFitter(f);
            double[] g = fitte.fit();
            // si stampano i risultati
            out.println("A: ....................." + df.format(g[0]));
            out.println("B: ....................." + df.format(g[1]));
            out.println("Sigma-A: ..............." + df.format(g[2]));
            out.println("Sigma-B: ..............." + df.format(g[3]));
            out.println("Sigma-AB: .............." + df.format(g[4]));
            out.println();
            break;
          default:
            out.println("Inserire comando valido!");
        }
      } catch (Exception e) {
        out.println(e.getMessage());
        continue;
      }
    }
  }
Esempio n. 4
0
 /**
  * Ciclo che gestisce i comandi per i test del chi quadro
  *
  * @throws IOException
  */
 private static void test_cycle() throws IOException {
   boolean test_cycle = true;
   while (test_cycle) {
     out.print("test>> ");
     String cmd2 = in.readLine().trim();
     if (cmd2.equals("exit")) {
       test_cycle = false;
       out.println("exit test menu...\n");
       continue;
     }
     String[] p = cmd2.split(" ");
     if (p.length < 2) {
       out.println("\tInserire id oggetto\n");
       continue;
     }
     String v = p[1];
     try {
       switch (p[0]) {
         case "histogram-test-c":
           // si crea un nuovo class-set con i parametri passati.
           Variable var1 = data.getVariable(v);
           if (p.length < 4) {
             out.println(
                 "data>> Inserire parametri:\n"
                     + " larghezza intervallo, freq relativa (true/false)\n");
             continue;
           }
           double inte = Double.parseDouble(p[2]);
           boolean fr_rel = Boolean.parseBoolean(p[3]);
           var1.getClassSet(inte, fr_rel);
           double[] res1 = ChiSquaredTest.testChiSquared_Histogram(var1);
           // si stampano i risultati
           out.println("Chi Quadro: ........................" + df.format(res1[0]));
           out.println("Chi Quadro ridotto: ................" + df.format(res1[1]));
           out.println("Probabilità: ......................." + df.format(res1[2]) + "%");
           out.println();
           break;
         case "histogram-test":
           // si esegue il test del chi per la variabile utilizzando il
           // class-set già presente, se c'è
           Variable var = data.getVariable(v);
           if (var.getLast_class_set() == null) {
             out.println("\tEseguire prima un class-set sulla variabile!\n");
             continue;
           }
           double[] res = ChiSquaredTest.testChiSquared_Histogram(var);
           // si stampano i risultati
           out.println("Chi Quadro: ........................" + df.format(res[0]));
           out.println("Chi Quadro ridotto: ................" + df.format(res[1]));
           out.println("Probabilità: ......................." + df.format(res[2]) + "%");
           out.println();
           break;
         case "fitting-test":
           // si esegue il test del chi per un'interpolazione lineare.
           LinearFitter fitter = fitter_man.getLinearFitter(v);
           if (fitter.isFitted()) {
             double[] re = ChiSquaredTest.testChiSquared_LinearFitting(fitter);
             // si stampano i risultati
             out.println("Chi Quadro: ........................" + df.format(re[0]));
             out.println("Chi Quadro ridotto: ................" + df.format(re[1]));
             out.println("Probabilità: ......................." + df.format(re[2]) + "%");
             out.println();
           } else {
             out.println("\tEseguire prima un fitting sui dati!\n");
             continue;
           }
           break;
         default:
           out.println("Inserire comando valido!");
       }
     } catch (Exception e) {
       out.println(e.getMessage());
       continue;
     }
   }
 }