integrate verrou precis tp

CalculVerrou/src/corrige/etape1.0/Makefile

+
+all: cvPlot.pdf
+
+integrate: integrate.cxx
+	g++ -Wall -g -O3 -o $@ $<
+
+cvPlot.pdf: integrate cvPlot.gp
+	./cvPlot

CalculVerrou/src/corrige/etape1.0/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

CalculVerrou/src/corrige/etape1.0/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

CalculVerrou/src/corrige/etape1.0/integrate.cxx

+#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;
+}

CalculVerrou/src/corrige/etape1.1/Makefile

+
+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

CalculVerrou/src/corrige/etape1.1/compare

+#!/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)

CalculVerrou/src/corrige/etape1.1/cvPlot

+#!/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

CalculVerrou/src/corrige/etape1.1/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"

CalculVerrou/src/corrige/etape1.1/integrate.cxx

+#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;
+}

CalculVerrou/src/corrige/etape2.0/Makefile

+
+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

CalculVerrou/src/corrige/etape2.0/compare

+#!/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)

CalculVerrou/src/corrige/etape2.0/cvPlot

+#!/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

CalculVerrou/src/corrige/etape2.0/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"

CalculVerrou/src/corrige/etape2.0/integrate.cxx

+#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;
+}

CalculVerrou/src/corrige/etape2.1/Makefile

+
+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

CalculVerrou/src/corrige/etape2.1/compare

+#!/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)

CalculVerrou/src/corrige/etape2.1/cvPlot

+#!/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

CalculVerrou/src/corrige/etape2.1/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"

CalculVerrou/src/corrige/etape2.1/ddCmp

+#!/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)

CalculVerrou/src/corrige/etape2.1/ddRun

+#!/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