/**
* 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();
}
/**
* 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);
}
/**
* 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;
}
}
}
/**
* 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;
}
}
}