Commit 9ba4bd10 authored by CHAMONT David's avatar CHAMONT David
Browse files

integrate verrou precis tp

parent 961eafb1
all: cvPlot.pdf
integrate: integrate.cxx
g++ -Wall -g -O3 -o $@ $<
cvPlot.pdf: integrate cvPlot.gp
./cvPlot
#!/bin/bash
# Réalise l'étude de convergence du calcul d'intégrale
./integrate 1.1 >cvPlot.dat
# Produit une courbe représentant l'erreur en fonction du nombre de rectangles dans "cvPlot.pdf"
gnuplot cvPlot.gp
#!/usr/bin/gnuplot
set xlabel "Nb rectangles"
set format x "%.0e"
set ylabel "Erreur"
set format y "%.0e"
set logscale xy
plot "cvPlot.dat" using 1:3 notitle
#include <iostream>
#include <iomanip>
#include <cmath>
#include <functional>
#include <sstream>
typedef double RealType;
/** Calcule l'intégrale d'une fonction entre deux bornes avec la méthode des
rectangles.
@param f la fonction à intégrer
@param x0 borne gauche de l'intervalle d'intégration
@param x1 borne droite
@param n nombre de rectangles
*/
template <typename T>
RealType integrate (const T& f, RealType a, RealType b, unsigned int n) {
// Pas d'intégration
const RealType dx = (b - a) / n;
// Accumulateur
RealType sum = 0.;
// Boucle sur les rectangles d'intégration
for (RealType x = a + 0.5 * dx ;
x < b ;
x += dx) {
sum += dx * f(x);
}
return sum;
}
/** Teste la convergence du calcul d'intégrale avec le nombre de rectangles.
On utilise comme cas-test le calcul de l'intégrale de cos entre 0 et pi/2,
dont la valeur exacte est 1.
Le même calcul est réalisé pour une suite croissante (~géométrique) de
nombre de rectangles. Chaque résultat de calcul est affiché en sortie.
@param step facteur entre deux nombre de rectangles testés
*/
void testConvergence (RealType step) {
for (unsigned int n = 1 ;
n <= 100000 ;
n = std::max ((unsigned int)(step*n), n+1)) {
// Calcul approché
RealType res = integrate ((RealType(*)(RealType)) std::cos,
0, M_PI_2, n);
// Erreur (relative) par rapport à la valeur exacte
RealType err = std::abs(1 - res);
// Affichage en sortie sur trois colonnes:
// Nrectangles Resultat Erreur
std::cout << std::setw(10) << n << " " << res << " " << err << std::endl;
}
}
/** Fonction utilitaire de conversion de chaîne
@param str la chaîne à convertir
@param TO le type de donnée à lire
*/
template <typename TO>
TO strTo (const std::string & str) {
std::istringstream iss(str);
TO x;
iss >> x;
return x;
}
/** Fonction principale : le facteur de croissance des nombre de rectangles
testés est lu comme premier argument en ligne de commande.
*/
int main (int argc, char **argv) {
const RealType step = strTo<RealType> (argv[1]);
testConvergence (step);
return 0;
}
all: checkInstr cvPlot.pdf
integrate: integrate.cxx
g++ -Wall -g -O3 -o $@ $<
checkInstr: integrate
./integrate 10 > res.natif
valgrind --tool=none ./integrate 10 > res.none
valgrind ./integrate 10 > res.memcheck
valgrind --tool=verrou --rounding-mode=nearest ./integrate 10 > res.vrnearest
diff res.natif res.none
diff res.natif res.memcheck
diff res.natif res.vrnearest
libm.ex: integrate
valgrind --tool=verrou --demangle=no --gen-exclude=all.ex ./integrate 1e5
grep libm all.ex | tee libm.ex
cvPlot.pdf: libm.ex cvPlot.gp
./cvPlot
#!/usr/bin/env python
import sys
import numpy
def readDat (fname):
dat = []
with open (fname, "r") as f:
for line in f:
cols = line.split()
dat.append ((int(cols[0]), float(cols[1])))
return dat
dat = [readDat (fname) for fname in sys.argv[1:]]
ret = []
for i in xrange(len(dat[0])):
val = [d[i][1] for d in dat]
avg = numpy.mean (val)
std = numpy.std (val)
print "%d %.16e %.16e" % (dat[0][i][0], avg, std)
#!/bin/bash
# Réalise l'étude de convergence du calcul d'intégrale
./integrate 1.1 >cvPlot0.dat
# Rejoue la même étude dans Verrou
VERROU="valgrind --tool=verrou --rounding-mode=random --exclude=libm.ex"
${VERROU} ./integrate 1.1 >cvPlot1.dat 2>/dev/null
${VERROU} ./integrate 1.1 >cvPlot2.dat 2>/dev/null
${VERROU} ./integrate 1.1 >cvPlot3.dat 2>/dev/null
# Analyse la variabilité des résultats
./compare cvPlot?.dat >cvPlotVerrou.dat
# Produit une courbe représentant l'erreur en fonction du nombre de rectangles dans "cvPlot.pdf"
gnuplot cvPlot.gp
#!/usr/bin/gnuplot
set xlabel "Nb rectangles"
set format x "%.0e"
set ylabel "Erreur"
set format y "%.0e"
set logscale xy
plot "cvPlot0.dat" using 1:3 title "Evaluation native", \
"cvPlotVerrou.dat" using 1:3 title "Evaluation Verrou"
#include <iostream>
#include <iomanip>
#include <cmath>
#include <functional>
#include <sstream>
typedef double RealType;
/** Calcule l'intégrale d'une fonction entre deux bornes avec la méthode des
rectangles.
@param f la fonction à intégrer
@param x0 borne gauche de l'intervalle d'intégration
@param x1 borne droite
@param n nombre de rectangles
*/
template <typename T>
RealType integrate (const T& f, RealType a, RealType b, unsigned int n) {
// Pas d'intégration
const RealType dx = (b - a) / n;
// Accumulateur
RealType sum = 0.;
// Boucle sur les rectangles d'intégration
for (RealType x = a + 0.5 * dx ;
x < b ;
x += dx) {
sum += dx * f(x);
}
return sum;
}
/** Teste la convergence du calcul d'intégrale avec le nombre de rectangles.
On utilise comme cas-test le calcul de l'intégrale de cos entre 0 et pi/2,
dont la valeur exacte est 1.
Le même calcul est réalisé pour une suite croissante (~géométrique) de
nombre de rectangles. Chaque résultat de calcul est affiché en sortie.
@param step facteur entre deux nombre de rectangles testés
*/
void testConvergence (RealType step) {
std::cout << std::scientific << std::setprecision(16);
for (unsigned int n = 1 ;
n <= 100000 ;
n = std::max ((unsigned int)(step*n), n+1)) {
// Calcul approché
RealType res = integrate ((RealType(*)(RealType)) std::cos,
0, M_PI_2, n);
// Erreur (relative) par rapport à la valeur exacte
RealType err = std::abs(1 - res);
// Affichage en sortie sur trois colonnes:
// Nrectangles Resultat Erreur
std::cout << std::setw(10) << n << " " << res << " " << err << std::endl;
}
}
/** Fonction utilitaire de conversion de chaîne
@param str la chaîne à convertir
@param TO le type de donnée à lire
*/
template <typename TO>
TO strTo (const std::string & str) {
std::istringstream iss(str);
TO x;
iss >> x;
return x;
}
/** Fonction principale : le facteur de croissance des nombre de rectangles
testés est lu comme premier argument en ligne de commande.
*/
int main (int argc, char **argv) {
const RealType step = strTo<RealType> (argv[1]);
testConvergence (step);
return 0;
}
all: checkInstr cvPlot.pdf
integrate: integrate.cxx
g++ -Wall -g -O3 -o $@ $<
checkInstr: integrate
./integrate 10 > res.natif
valgrind --tool=none ./integrate 10 > res.none
valgrind ./integrate 10 > res.memcheck
valgrind --tool=verrou --rounding-mode=nearest ./integrate 10 > res.vrnearest
diff res.natif res.none
diff res.natif res.memcheck
diff res.natif res.vrnearest
libm.ex: integrate
valgrind --tool=verrou --demangle=no --gen-exclude=all.ex ./integrate 1e5
grep libm all.ex | tee libm.ex
cvPlot.pdf: libm.ex cvPlot.gp
./cvPlot
#!/usr/bin/env python
import sys
import numpy
def readDat (fname):
dat = []
with open (fname, "r") as f:
for line in f:
cols = line.split()
dat.append ((int(cols[0]), float(cols[1])))
return dat
dat = [readDat (fname) for fname in sys.argv[1:]]
ret = []
for i in xrange(len(dat[0])):
val = [d[i][1] for d in dat]
avg = numpy.mean (val)
std = numpy.std (val)
print "%d %.16e %.16e" % (dat[0][i][0], avg, std)
#!/bin/bash
# Réalise l'étude de convergence du calcul d'intégrale
./integrate 1.1 >cvPlot0.dat
# Rejoue la même étude dans Verrou
VERROU="valgrind --tool=verrou --rounding-mode=random --exclude=libm.ex"
${VERROU} ./integrate 1.1 >cvPlot1.dat 2>/dev/null
${VERROU} ./integrate 1.1 >cvPlot2.dat 2>/dev/null
${VERROU} ./integrate 1.1 >cvPlot3.dat 2>/dev/null
# Analyse la variabilité des résultats
./compare cvPlot?.dat >cvPlotVerrou.dat
# Produit une courbe représentant l'erreur en fonction du nombre de rectangles dans "cvPlot.pdf"
gnuplot cvPlot.gp
#!/usr/bin/gnuplot
set xlabel "Nb rectangles"
set format x "%.0e"
set ylabel "Erreur"
set format y "%.0e"
set logscale xy
plot "cvPlot0.dat" using 1:3 title "Evaluation native", \
"cvPlotVerrou.dat" using 1:3 title "Evaluation Verrou"
#include <iostream>
#include <iomanip>
#include <cmath>
#include <functional>
#include <sstream>
typedef float RealType;
/** Calcule l'intégrale d'une fonction entre deux bornes avec la méthode des
rectangles.
@param f la fonction à intégrer
@param x0 borne gauche de l'intervalle d'intégration
@param x1 borne droite
@param n nombre de rectangles
*/
template <typename T>
RealType integrate (const T& f, RealType a, RealType b, unsigned int n) {
// Pas d'intégration
const RealType dx = (b - a) / n;
// Accumulateur
RealType sum = 0.;
// Boucle sur les rectangles d'intégration
for (RealType x = a + 0.5 * dx ;
x < b ;
x += dx) {
sum += dx * f(x);
}
return sum;
}
/** Teste la convergence du calcul d'intégrale avec le nombre de rectangles.
On utilise comme cas-test le calcul de l'intégrale de cos entre 0 et pi/2,
dont la valeur exacte est 1.
Le même calcul est réalisé pour une suite croissante (~géométrique) de
nombre de rectangles. Chaque résultat de calcul est affiché en sortie.
@param step facteur entre deux nombre de rectangles testés
*/
void testConvergence (RealType step) {
std::cout << std::scientific << std::setprecision(16);
for (unsigned int n = 1 ;
n <= 100000 ;
n = std::max ((unsigned int)(step*n), n+1)) {
// Calcul approché
RealType res = integrate ((RealType(*)(RealType)) std::cos,
0, M_PI_2, n);
// Erreur (relative) par rapport à la valeur exacte
RealType err = std::abs(1 - res);
// Affichage en sortie sur trois colonnes:
// Nrectangles Resultat Erreur
std::cout << std::setw(10) << n << " " << res << " " << err << std::endl;
}
}
/** Fonction utilitaire de conversion de chaîne
@param str la chaîne à convertir
@param TO le type de donnée à lire
*/
template <typename TO>
TO strTo (const std::string & str) {
std::istringstream iss(str);
TO x;
iss >> x;
return x;
}
/** Fonction principale : le facteur de croissance des nombre de rectangles
testés est lu comme premier argument en ligne de commande.
*/
int main (int argc, char **argv) {
const RealType step = strTo<RealType> (argv[1]);
testConvergence (step);
return 0;
}
all: cvPlot.pdf dd
integrate: integrate.cxx
g++ -Wall -g -O3 -o $@ $<
checkInstr: integrate
./integrate 10 > res.natif
valgrind --tool=none ./integrate 10 > res.none
valgrind ./integrate 10 > res.memcheck
valgrind --tool=verrou --rounding-mode=nearest ./integrate 10 > res.vrnearest
diff res.natif res.none
diff res.natif res.memcheck
diff res.natif res.vrnearest
libm.ex: integrate
valgrind --tool=verrou --demangle=no --gen-exclude=all.ex ./integrate 1e5
grep libm all.ex | tee libm.ex
cvPlot.pdf: libm.ex cvPlot.gp
./cvPlot
export VERROU_DD_NRUNS = 10
dd: integrate
rm -rf dd.*
verrou_dd ${PWD}/ddRun ${PWD}/ddCmp
#!/usr/bin/env python
import sys
import numpy
def readDat (fname):
dat = []
with open (fname, "r") as f:
for line in f:
cols = line.split()
dat.append ((int(cols[0]), float(cols[1])))
return dat
dat = [readDat (fname) for fname in sys.argv[1:]]
ret = []
for i in xrange(len(dat[0])):
val = [d[i][1] for d in dat]
avg = numpy.mean (val)
std = numpy.std (val)
print "%d %.16e %.16e" % (dat[0][i][0], avg, std)
#!/bin/bash
# Réalise l'étude de convergence du calcul d'intégrale
./integrate 1.1 >cvPlot0.dat
# Rejoue la même étude dans Verrou
VERROU="valgrind --tool=verrou --rounding-mode=random --exclude=libm.ex"
${VERROU} ./integrate 1.1 >cvPlot1.dat 2>/dev/null
${VERROU} ./integrate 1.1 >cvPlot2.dat 2>/dev/null
${VERROU} ./integrate 1.1 >cvPlot3.dat 2>/dev/null
# Analyse la variabilité des résultats
./compare cvPlot?.dat >cvPlotVerrou.dat
# Produit une courbe représentant l'erreur en fonction du nombre de rectangles dans "cvPlot.pdf"
gnuplot cvPlot.gp
#!/usr/bin/gnuplot
set xlabel "Nb rectangles"
set format x "%.0e"
set ylabel "Erreur"
set format y "%.0e"
set logscale xy
plot "cvPlot0.dat" using 1:3 title "Evaluation native", \
"cvPlotVerrou.dat" using 1:3 title "Evaluation Verrou"
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
# Arguments en ligne de commande:
# - répertoire contenant les sorties de référence
# - répertoire contenant les sorties à évaluer
REFDIR = sys.argv[1]
CURDIR = sys.argv[2]
def readResult (dirname):
with open ("%s/res.dat" % dirname, "r") as f:
for line in f:
# On écrase à chaque fois le résultat pour ne garder que la dernière
# ligne. C'est la deuxième colonne qui nous intéresse (i.e. le résultat
# du calcul)
result = float (line.split()[1])
return result
ref = readResult (REFDIR)
cur = readResult (CURDIR)
# Calcul et affichage de l'écart entre résultats
diff = abs (ref - cur) / ref
print "%.16e" % diff
# Si l'écart est trop important : ERREUR
if diff > 1e-5:
sys.exit (1)
# Sinon : SUCCES
sys.exit(0)
#!/bin/bash
# Arguments en ligne de commande:
# - le répertoire où les résultats doivent être stockés
OUTDIR=$1
# Lancement du code avec Verrou, en stockant les résultats dans ${OUTDIR}
valgrind --tool=verrou --demangle=no --rounding-mode=random --exclude=libm.ex ./integrate 10 >${OUTDIR}/res.dat
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment