git » metnum-tp1.git » master » tree

[master] / gen_plot_data.sh 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#!/bin/bash

# Directorio de salida, coordinado con el graficador
OUTDIR="out/"
mkdir -p $OUTDIR

# Minima y maxima precision a calcular
minprec=10
maxprec=51

# Tabla con los algoritmos a usar, y la cantidad minima y maxima de
# iteraciones para el mismo
declare -A maxiter
declare -A miniter
miniter["babilonio"]=1
maxiter["babilonio"]=50
miniter["binomial"]=1
maxiter["binomial"]=200		# mas, da NaN
miniter["binomial_inc"]=1
maxiter["binomial_inc"]=200	# mas, da NaN
miniter["binomial_dec"]=1
maxiter["binomial_dec"]=600
miniter["fcont"]=1
maxiter["fcont"]=50
miniter["fcont_int"]=1
maxiter["fcont_int"]=50

# Algunos algoritmos son incrementales, y nos dan los resultados en cada
# iteración hasta que llegan a la indicada en la linea de comandos, para
# optimizar las corridas. Estos estan indicados en este arreglo.
declare -A isincr
isincr["binomial"]=1
isincr["binomial_inc"]=1
isincr["binomial_dec"]=1

algolist=${!maxiter[*]}


# Corremos y guardamos en archivos por algoritmo y por precision
for algo in $algolist; do
	echo -n "$algo " >&2
	for prec in `seq $minprec $maxprec`; do
		echo -n "$prec " >&2
		OF="$OUTDIR/OUT-$algo-prec:$prec"
		rm -f "$OF"

		# Si no es incremental, entonces hacemos nosotros a mano el
		# loop para cada iteración; sino directamente corremos el
		# programa con la máxima iteración buscada
		if [ "${isincr[$algo]}" == "" ]; then
			for iter in `seq ${miniter[$algo]} ${maxiter[$algo]}`; do
				./$algo $prec $iter >> "$OF"
			done
		else
			./$algo $prec ${maxiter[$algo]} > "$OF"
		fi

		# Obtenemos los errores de cada resultado
		cat "$OF" | ./err.py > "$OF-err"
	done
	echo >&2
done


# Obtenemos archivos por iteracion, asegurandonos que esten bien ordenados
# para no confundir al graficador
echo "iter split"
for algo in $algolist; do
	for iter in `seq 1 ${maxiter[$algo]}`; do
		cat "$OUTDIR"/OUT-$algo-prec:*-err | egrep "^$iter " \
			| sort -n -k 2 \
			> "$OUTDIR/OUT-$algo-iter:$iter-err"
	done
done

# Armamos un gran archivo para los plots 3D, dejando lineas en blanco entre
# las distintas "tiradas" de precision
echo "iter join"
for algo in $algolist; do
	OF="$OUTDIR/OUT-$algo-all-err"
	rm -f $OF
	for f in "$OUTDIR"/OUT-$algo-prec:*-err; do
		cat "$f" >> $OF
		echo >> $OF
	done
done