{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" } }, "cells": [ { "cell_type": "markdown", "source": [ "Comment déterminer l'incertitude-type d'une variable $x$ ?\n", "\n", " avec $x=6,4$ et $m=0,1$" ], "metadata": { "id": "lc2fQZ7a3D66" } }, { "cell_type": "code", "source": [ "import numpy as np\t#Importe la bibliothèque pour faire divers calculs\n", "import numpy.random as rd\t#Importe la fonction de tirage aléatoire rectangulaire\n", "import matplotlib.pyplot as plt\n", "x = 6.4 #valeur de x\n", "m_x=0.1 #demi-étendu de x\n", "N_sim =10000 \t#Nombre de tirage\n", "xlist=rd.uniform(x-m_x, x+m_x, N_sim) #vecteur de N_sim valeurs aléatoires de x\n", "x_moy=np.mean(xlist) #moyenne de x\n", "u_x= np.std(xlist, ddof=1) #écart-type de x\n", "print (\"x=\",format(x_moy,\"#.3f\"),\" avec u(x) = \",format(u_x,\"#.1e\"),\" à comparer à m/racine(3) =\",format(m_x/np.sqrt(3),\"#.1e\")) #Affiche x et incertitude type\n", "\n", "plt.hist(xlist, bins='rice', histtype = 'step') # Tracé histogramme\n", "plt.show()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 283 }, "id": "TcINuLBb3Vzu", "outputId": "9f8f292c-64aa-4805-c95f-cc1f58d64915" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "x= 6.400 avec u(x) = 5.8e-02 à comparer à m/racine(3) = 5.8e-02\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "metadata": { "id": "f6QwaPwX0z7p" }, "source": [ "Comment déterminer l'incertitude-type d'un fonction logarithme décimale $log(x)$ ?\n", "\n", " avec $x=6,4$ et $m=0,1$" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 283 }, "id": "YorOXsEaSIj1", "outputId": "7b0cd029-08bb-447d-a207-1db7a6d3e2b1" }, "source": [ "import numpy as np\t#Importe la bibliothèque pour faire divers calculs\n", "import numpy.random as rd\t#Importe la fonction de tirage aléatoire rectangulaire\n", "import matplotlib.pyplot as plt\n", "x = 6.4 #valeur de x\n", "m_x=0.1 #demi-étendu de x\n", "N_sim =10000 \t#Nombre de tirage\n", "xlist=rd.uniform(x-m_x, x+m_x, N_sim) #vecteur de N_sim valeurs aléatoires de x\n", "y=np.log10(xlist) # calcul des N_sim valeurs de y\n", "fx=np.mean(y) #moyenne de y\n", "u_fx= np.std(y, ddof=1) #écart-type de y\n", "print (\"log(x)=\",format(fx,\"#.4f\"),\" avec u(log(x)) = \",format(u_fx,\"#.1e\")) #Affiche y et incertitude type\n", "\n", "plt.hist(y, bins='rice', histtype = 'step') # Tracé histogramme\n", "plt.show()" ], "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "log(x)= 0.8061 avec u(log(x)) = 3.9e-03\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "metadata": { "id": "V17jXG8QPMv4" }, "source": [ "Comment déterminer l'incertitude-type d'un fonction exponentielle $exp(x)$ ?\n", "\n", " avec $x=6,4$ et $m=0,1$" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 283 }, "id": "t7c_zLQHLn89", "outputId": "bd47be32-5409-4e8d-fb65-8c552b9cabce" }, "source": [ "import numpy as np\t#Importe la bibliothèque pour faire divers calculs\n", "import numpy.random as rd\t#Importe la fonction de tirage aléatoire rectangulaire\n", "import matplotlib.pyplot as plt\n", "x = 6.4 #valeur de x\n", "m_x=0.1 #demi-étendu de x\n", "N_sim =10000 \t#Nombre de tirage\n", "xlist=rd.uniform(x-m_x, x+m_x, N_sim) #vecteur de N_sim valeurs aléatoires de x\n", "y=np.exp(xlist) # calcul des N_sim valeurs de y\n", "fx=np.mean(y) #moyenne de y\n", "u_fx= np.std(y, ddof=1) #écart-type de y\n", "print (\"exp(x)=\",format(fx,\"#.2e\"),\" avec u(exp(x)) = \",format(u_fx,\"#.1e\")) #Affiche y et incertitude type\n", "\n", "plt.hist(y, bins='rice', histtype = 'step') # Tracé histogramme\n", "plt.show()" ], "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "exp(x)= 6.03e+02 avec u(exp(x)) = 3.5e+01\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "source": [ "Comment déterminer l'incertitude-type d'une variable $x$ ?\n", "\n", " avec $x=6,4$ et $m=0,01$" ], "metadata": { "id": "qfyLTTCl4uHY" } }, { "cell_type": "code", "source": [ "import numpy as np\t#Importe la bibliothèque pour faire divers calculs\n", "import numpy.random as rd\t#Importe la fonction de tirage aléatoire rectangulaire\n", "import matplotlib.pyplot as plt\n", "x = 6.4 #valeur de x\n", "m_x=0.01 #demi-étendu de x\n", "N_sim =10000 \t#Nombre de tirage\n", "xlist=rd.uniform(x-m_x, x+m_x, N_sim) #vecteur de N_sim valeurs aléatoires de x\n", "x_moy=np.mean(xlist) #moyenne de x\n", "u_x= np.std(xlist, ddof=1) #écart-type de x\n", "print (\"x=\",format(x_moy,\"#.4f\"),\" avec u(x) = \",format(u_x,\"#.1e\"),\" à comparer à m/racine(3) =\",format(m_x/np.sqrt(3),\"#.1e\")) #Affiche x et incertitude type\n", "\n", "plt.hist(xlist, bins='rice', histtype = 'step') # Tracé histogramme\n", "plt.show()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 283 }, "id": "N3EvhDnz4z36", "outputId": "f4e17f17-bbad-4c25-db98-a3967495df7e" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "x= 6.3999 avec u(x) = 5.8e-03 à comparer à m/racine(3) = 5.8e-03\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "metadata": { "id": "0mCIyRYD9WRJ" }, "source": [ "Comment déterminer l'incertitude-type d'un fonction logarithme décimale $log(x)$ ?\n", "\n", " avec $x=6,4$ et $m=0,01$" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 283 }, "id": "tfIGx4uv9cPq", "outputId": "c0d707c8-484b-4b4f-e961-8de8213785f2" }, "source": [ "import numpy as np\t#Importe la bibliothèque pour faire divers calculs\n", "import numpy.random as rd\t#Importe la fonction de tirage aléatoire rectangulaire\n", "import matplotlib.pyplot as plt\n", "x = 6.4 #valeur de x\n", "m_x=0.01 #demi-étendu de x\n", "N_sim =10000 \t#Nombre de tirage\n", "xlist=rd.uniform(x-m_x, x+m_x, N_sim) #vecteur de N_sim valeurs aléatoires de x\n", "y=np.log10(xlist) # calcul des N_sim valeurs de y\n", "fx=np.mean(y) #moyenne de y\n", "u_fx= np.std(y, ddof=1) #écart-type de y\n", "print (\"log(x)=\",format(fx,\"#.5f\"),\" avec u(log(x)) = \",format(u_fx,\"#.1e\")) #Affiche y et incertitude type\n", "\n", "plt.hist(y, bins='rice', histtype = 'step') # Tracé histogramme\n", "plt.show()" ], "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "log(x)= 0.80618 avec u(log(x)) = 3.9e-04\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAQaklEQVR4nO3dfaxkdX3H8fdHVqxFKtBdt3RZumiwKfxRtLdogzUoiQJtuvgPgbQKSrPWoKnGtF00qcSGBMWH2KSlWYu6tipShUpSbEG0tVpB71JAHqRucQm7Xdi1PrYaDPjtH3O2jsu9d+7TzD33d9+vZDK/+Z2H+c7cOZ858ztn5qaqkCS15SkrXYAkafkZ7pLUIMNdkhpkuEtSgwx3SWrQupUuAGD9+vW1ZcuWlS5DklaVXbt2fbOqNsw0rRfhvmXLFqanp1e6DElaVZI8NNs0h2UkqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWrQyHBPsjnJ55Lcl+TeJH/Y9V+eZF+SO7vLuUPLXJZkd5IHkrx8nA9AkvRk8/kS0+PAm6vqjiRHA7uS3NJNe29VvWt45iSnABcApwK/CHwmyXOr6onlLFySNLuR4V5V+4H9Xfv7Se4HNs2xyFbg2qp6DPhGkt3A6cCXlqHeFXfGlZ9l33d+OOO0Tcc8nS9uf+mEK5KkJ1vQzw8k2QI8D7gdOAN4fZJXAdMM9u6/zSD4bxtabC8zvBkk2QZsAzjxxBMXUfrK2PedH7Lnyt+acdqW7f8w4Wqk8XFHZnWbd7gneQbwSeCNVfW9JFcDfwZUd/1u4DXzXV9V7QB2AExNTfm//qSecUdmdZvX2TJJnsog2D9SVdcDVNWjVfVEVf0YeD+DoReAfcDmocVP6PokSRMycs89SYBrgPur6j1D/cd34/EArwDu6do3Ah9N8h4GB1RPBr68rFVLy8whCLVmPsMyZwCvBL6a5M6u7y3AhUlOYzAsswd4LUBV3ZvkOuA+BmfaXLrazpQZtaH3qZZWQ2fSj3uSQxBr9W+qyZrP2TJfADLDpJvmWOYK4Iol1LWi5trQJ22tjnu2/LhbfmzqD7+hKkkNMtwlqUG9+Dd7Wn6O60prm+HeKMd1pbXNcJ8Q96QlTZLhPiHuSUurQys7Yoa7JA1pZUfMcJe05vTpi4rjYrhLSzBbSIzj43srwwV90KcvKo7Lqg93X/Brz6Zjnj7rx+NJ/81nC4lxfHxvZbhAk7Hqw90X/GT06U10rvvqy9981BuQ2tOnbQQaCHdNhm+iC+MnxrWnb9vImg33cRxQmfTemnuHWm36tnfbsjUb7uM4oDLpF6YbwmT4Jrp8+rZ327I1G+7SfPkmurLc218cw11j1acNcy2c29wi9/YXx3DXWPVpw1wL5zZLhxju+n/u2a68cYzvj+PT01x1jlpOk9F0uHsgbGHcs1154ximmuvvesaVn13UNuI4d/81He6+ALVWLHZHxm2kXU2Hu7RWGNJPttaHGQ13Sb0w26ePxQZxn4YZV+L3kAx3Sb3Q8qePlfg9pKeMZa2SpBXlnruWrE9nJfWpFmklGe5asj59nO5TLdJKclhGkhpkuEtSgwx3SWqQY+49sFYPAq7Vx63VazW9Zg33HlirBwHX6uPW6rWaXrMOy0hSg0buuSfZDHwY2AgUsKOq3pfkOODjwBZgD3B+VX07SYD3AecCPwAurqo7xlO+pLVsNQ2TTNp8hmUeB95cVXckORrYleQW4GLg1qq6Msl2YDvwJ8A5wMnd5QXA1d21JC2r1TRMMmkjh2Wqav+hPe+q+j5wP7AJ2Ars7GbbCZzXtbcCH66B24Bjkhy/7JVLkma1oDH3JFuA5wG3Axuran836REGwzYwCP6Hhxbb2/Udvq5tSaaTTB88eHCBZUuS5jLvcE/yDOCTwBur6nvD06qqGIzHz1tV7aiqqaqa2rBhw0IWlSSNMK9wT/JUBsH+kaq6vut+9NBwS3d9oOvfB2weWvyErk+SNCEjw707++Ua4P6qes/QpBuBi7r2RcCnhvpflYEXAt8dGr6RJE3AfM6WOQN4JfDVJHd2fW8BrgSuS3IJ8BBwfjftJganQe5mcCrkq5e1YknSSCPDvaq+AGSWyWfNMH8Bly6xLo3Rcv87M0n9488PrEGeGyy1z58fkKQGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQSPDPckHkhxIcs9Q3+VJ9iW5s7ucOzTtsiS7kzyQ5OXjKlySNLv57Ll/CDh7hv73VtVp3eUmgCSnABcAp3bL/GWSI5arWEnS/IwM96r6PPCtea5vK3BtVT1WVd8AdgOnL6E+SdIiLGXM/fVJ7u6GbY7t+jYBDw/Ns7frkyRN0GLD/WrgOcBpwH7g3QtdQZJtSaaTTB88eHCRZUiSZrKocK+qR6vqiar6MfB+fjL0sg/YPDTrCV3fTOvYUVVTVTW1YcOGxZQhSZrFosI9yfFDN18BHDqT5kbggiRPS3IScDLw5aWVKElaqHWjZkjyMeBMYH2SvcDbgDOTnAYUsAd4LUBV3ZvkOuA+4HHg0qp6YjylS5JmMzLcq+rCGbqvmWP+K4ArllKUJGlp/IaqJDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUEjwz3JB5IcSHLPUN9xSW5J8vXu+tiuP0n+PMnuJHcnef44i5ckzWw+e+4fAs4+rG87cGtVnQzc2t0GOAc4ubtsA65enjIlSQsxMtyr6vPAtw7r3grs7No7gfOG+j9cA7cBxyQ5frmKlSTNz2LH3DdW1f6u/QiwsWtvAh4emm9v1ydJmqAlH1CtqgJqocsl2ZZkOsn0wYMHl1qGJGnIYsP90UPDLd31ga5/H7B5aL4Tur4nqaodVTVVVVMbNmxYZBmSpJksNtxvBC7q2hcBnxrqf1V31swLge8ODd9IkiZk3agZknwMOBNYn2Qv8DbgSuC6JJcADwHnd7PfBJwL7AZ+ALx6DDVLkkYYGe5VdeEsk86aYd4CLl1qUZKkpfEbqpLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1KB1S1k4yR7g+8ATwONVNZXkOODjwBZgD3B+VX17aWVKkhZiOfbcX1JVp1XVVHd7O3BrVZ0M3NrdliRN0DiGZbYCO7v2TuC8MdyHJGkOSw33Am5OsivJtq5vY1Xt79qPABtnWjDJtiTTSaYPHjy4xDIkScOWNOYOvKiq9iV5FnBLkq8NT6yqSlIzLVhVO4AdAFNTUzPOI0lanCXtuVfVvu76AHADcDrwaJLjAbrrA0stUpK0MIsO9yRHJTn6UBt4GXAPcCNwUTfbRcCnllqkJGlhljIssxG4Icmh9Xy0qv4xyVeA65JcAjwEnL/0MiVJC7HocK+qB4FfnaH/v4GzllKUJGlp/IaqJDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUFjC/ckZyd5IMnuJNvHdT+SpCcbS7gnOQL4C+Ac4BTgwiSnjOO+JElPNq4999OB3VX1YFX9CLgW2Dqm+5IkHWbdmNa7CXh46PZe4AXDMyTZBmzrbv5PkgcWe2d5x2KXHGk98M2xrX35rbZ6wZonxZonY1E1LyHDfmm2CeMK95GqagewY6Xufz6STFfV1ErXMV+rrV6w5kmx5snoU83jGpbZB2weun1C1ydJmoBxhftXgJOTnJTkSOAC4MYx3Zck6TBjGZapqseTvB74J+AI4ANVde847mvMej1sNIPVVi9Y86RY82T0puZU1UrXIElaZn5DVZIaZLhLUoOaDvdRP4GQ5MQkn0vy70nuTnLu0LTLuuUeSPLyof49Sb6a5M4k04et7w1Jvpbk3iTv7HvNSU5Lctuh/iSn96jmY5J8ons+70/yG13/cUluSfL17vrYntd7Vdd3d5Ibkhyz0HonXfPQ9DcnqSTrV0PNPd7+ZnttLMv2N6uqavLC4EDufwLPBo4E7gJOOWyeHcDruvYpwJ6h9l3A04CTuvUc0U3bA6yf4f5eAnwGeFp3+1mroOabgXO69rnAP/eo5p3A73ftI4FjuvY7ge1dezvwjp7X+zJgXdd+x0LrXYmau9ubGZwQ8dBMr52+1Uy/t7/Zal7y9jfXpeU99/n8BEIBP9e1nwn8V9feClxbVY9V1TeA3d365vI64Mqqegygqg6sgppnW9eK1pzkmcCLgWsAqupHVfWdoWV2du2dwHl9rreqbq6qx7vlb2PwnY+FmvRzDPBe4I+79S7GpGvu5fY3oubl2P5m1XK4z/QTCJsOm+dy4PeS7AVuAt4wj2ULuDnJrgx+QuGQ5wK/meT2JP+S5NdXQc1vBK5K8jDwLuCyntR8EnAQ+GD38fevkxzVzbOxqvZ37UeAjT2vd9hrgE8vsN6J15xkK7Cvqu5aRK0rUjP93f7mqnk5tr9ZtRzu83Eh8KGqOoHBx6K/STLqOXlRVT2fwS9eXprkxV3/OuA44IXAHwHXJUnPa34d8Kaq2gy8iW7vogc1rwOeD1xdVc8D/pfBEMxPqcHn2XGcy7vs9SZ5K/A48JEx1AvLVHOSnwXeAvzpmOoctpzPc1+3v7lqHuv213K4z+cnEC4BrgOoqi8BP8Pgh39mXbaqDl0fAG7gJ0Mfe4Hra+DLwI+7dfW55ouA67v23zF6GGdSNe8F9lbV7V3/JxhsIACPJjkeoLte6MfvSddLkouB3wZ+t3tDWqhJ1vwcBnubdyXZ081/R5Jf6HHN0N/tb66al2P7m91yDuD36cLgHfNBBi/UQwdHTj1snk8DF3ftX2Ew5hXgVH764MiDDA62HAUc3c1/FPBvwNnd7T8A3t61n8vgI1p6XvP9wJld+yxgVx+e526+fwV+uWtfDlzVta/ipw+ovrPn9Z4N3Ads6NNrea6aD1vvHhZ3QHXSz3Mvt78RNS95+5vz8Sznyvp2YfCx6T8YHLl+a9f3duB3uvYpwBe7P8qdwMuGln1rt9wD/OSI9rO7ee8C7j20zm7akcDfAvcAdwAvXQU1vwjY1U27Hfi1PtTc9Z8GTAN3A38PHNv1/zxwK/B1BmdHHNfzenczCJo7u8tf9f05Pux+97CIcF+B57mX29+Impdl+5vt4s8PSFKDWh5zl6Q1y3CXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDfo/LhxXiHOJ/+EAAAAASUVORK5CYII=\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "metadata": { "id": "P9VXtGEa9icp" }, "source": [ "Comment déterminer l'incertitude-type d'un fonction exponentielle $exp(x)$ ?\n", "\n", " avec $x=6,4$ et $m=0,01$" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 283 }, "id": "wIY8mLyN9nVl", "outputId": "fc524893-67db-44fa-85ef-f2c8c7277fe6" }, "source": [ "import numpy as np\t#Importe la bibliothèque pour faire divers calculs\n", "import numpy.random as rd\t#Importe la fonction de tirage aléatoire rectangulaire\n", "import matplotlib.pyplot as plt\n", "x = 6.4 #valeur de x\n", "m_x=0.01 #demi-étendu de x\n", "N_sim =10000 \t#Nombre de tirage\n", "xlist=rd.uniform(x-m_x, x+m_x, N_sim) #vecteur de N_sim valeurs aléatoires de x\n", "y=np.exp(xlist) # calcul des N_sim valeurs de y\n", "fx=np.mean(y) #moyenne de y\n", "u_fx= np.std(y, ddof=1) #écart-type de y\n", "print (\"exp(x)=\",format(fx,\"#.1f\"),\" avec u(exp(x)) = \",format(u_fx,\"#.1f\")) #Affiche y et incertitude type\n", "\n", "plt.hist(y, bins='rice', histtype = 'step') # Tracé histogramme\n", "plt.show()" ], "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "exp(x)= 601.8 avec u(exp(x)) = 3.5\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "metadata": { "id": "PuzzptT0SLQz" }, "source": [ "**Question bonus :**\n", "Comment déterminer l'incertitude-type d'un produit ?\n", "\n", "$\\frac{2,4 \\times 4,52}{100}$ ici 100 est un entier sans incertitude" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 448 }, "id": "YnIUpliBzG21", "outputId": "3063abfc-d9d6-4dba-e388-8ef4f10c2fbe" }, "source": [ "import numpy as np\t#Importe la bibliothèque pour faire divers calculs\n", "import numpy.random as rd\t#Importe la fonction de tirage aléatoire rectangulaire\n", "import matplotlib.pyplot as plt\n", "x = 2.4 #valeur de x\n", "m_x=0.1 #demi-étendu de x\n", "y = 4.52 #valeur de y\n", "m_y=0.01 #demi-étendu de y\n", "N_sim =10000 \t#Nombre de tirage\n", "xlist=rd.uniform(x-m_x, x+m_x, N_sim) #vecteur de N_sim valeurs aléatoires de x\n", "ylist=rd.uniform(y-m_y, y+m_y, N_sim) #vecteur de N_sim valeurs aléatoires de y\n", "z=xlist*ylist/100 # calcul des N_sim valeurs de z\n", "f=np.mean(z) #moyenne de z\n", "u_f= np.std(z, ddof=1) #écart-type de z\n", "print (\"produit =\",format(f,\"#.4f\"),\" avec u(produit) = \",format(u_f,\"#.1e\")) #Affiche résultat et incertitude type\n", "\n", "plt.hist(z, bins='rice', histtype = 'step') # Tracé histogramme\n", "plt.show()\n" ], "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "produit = 0.1085 avec u(produit) = 2.6e-03\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ] }, { "cell_type": "markdown", "metadata": { "id": "fretsZx_aapq" }, "source": [ "Calculer pour le glucose $C_6H_{12}O_6$ la masse molaire et l'incertitude-type.\n", "\n", "$M_C=12,01074\\ g/mol$ et $m(M_C)=0,0008\\ g/mol$ ;\n", "\n", "$M_O=15,9994\\ g/mol$ et $m(M_O)=0,0003\\ g/mol$ ;\n", "\n", "$M_H=1,00794\\ g/mol$ et $m(M_H)=0,00007\\ g/mol$." ] } ] }