Example #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();
 }
Example #2
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;
      }
    }
  }