# data[].attributes.body
Point de départ :

les fonctions affines sont une notion étudiée en seconde,  et un outil qui doit pouvoir être utilisé en lycée dans les trois matières scientifiques, particulièrement dans le calcul du coefficient directeur de droites

On a donc conçu un programme à compléter ou à construire suivant le niveau des élèves afin qu’il permette de tester un calcul de coefficient directeur et d’ordonnée à l’origine

Il sera alors un outil de vérification ou d’aide pour une utilisation ultérieure en mathématiques’ en sciences physiques ou en SVT.

COTE PROF

PLACE DANS LES PROGRAMMES

- SVT    seconde nouveau programme : Le métabolisme des cellules

- Math : seconde : géométrie : représenter et caractériser les droites du plan
- PC : Loi de Snell-Descartes, La lumière, la relation de proportionnalité.

PREREQUIS

- équation fonction affine et coefficient directeur

- cellule

- connaissances de base Python

CAPACITES :

- Déterminer une équation de droite connaissant deux points

- communiquer des résultats sous forme tableau et graphique

- réaliser un programme sous Python qui permet de déterminer les équations  des tangentes (y = ax+b).

- faire le lien entre pente de la courbe, coefficient directeur de la droite et efficacité de la réaction biochimique....

-  Montrer par des arguments mathématiques que sans glucose, le substrat dioxygène est consommé très faiblement, et que avec Glucose, le substrat dioxygène est consommé très fortement --> Donc deux voix métaboliques différentes, à efficacités différentes (connaissances à construire)

-  Pour cela, retrouver les coefficients directeurs des tangentes aux courbes.  Comparer les coefficients directeurs.

MATH : programmer avec Python

PC : A partir du programme Python réaliser en maths, transforme le programme pour le calcul du coefficient directuer.Utiliser l

CAHIER DES CHARGES

Activité programmation 1 :

- compléter un programme Jeu pour apprendre à déterminer graphiquement  et tester à l'aide du programme.1

Activité traitement de données :

-      Traiter  des Résultats sous forme  tableaux et   graphiques de [O2]= f(temps)

-       déterminer graphiquement les tangentes aux deux phases de la courbe et trouver les coordonnées de deux points de chaque droite tangente

Activité programmation 2:

- réaliser un programme sous Python qui permette de déterminer automatiquement une équation de droite, (a et b), connaissant les coordonnées de deux point appartenant à cette droite.

-  Déterminer les équations des tangentes et leurs coefficient directeur, à l'aide de ce programme.

COTE ELEVE - CONDITIONS

par groupe de 2

au cours d'une ou deux séances de math ou de svt ou de PC

# data[].attributes.body
Loi de Snell-Descartes

# data[].attributes.attachment_link.readable_text
﻿
#
# permet de calculer le coeff dir et l'ordonnée à l'origine à l'aide de 2 points de la droite
#
#
aP=float()
bP=float()
a=float()
b=float()
rep=str()
prod=float()

xA=float(input("donne l'abscisse du premier point xA:"))
yA=float(input("donne l'ordonnée du premier point yA:"))
xB=float(input("donne l'abscisse du deuxième point xB:"))
yB=float(input("donne l'ordonnée du deuxième point yB:"))


aP=(yA-yB)/(xA-xB)
print("a=",aP)
bP=yB-aP*xB
print("b =",bP)




# data[].attributes.body
Utilisation de boucle if - Calcul du coefficient directeur et de l'ordonnée à l'origine

# data[].attributes.body
Utilisation de la fonction - notion image et antécédent

# data[].attributes.attachment_link.readable_text
﻿
# On vérifie que le coefficient directeur et l'ordonnée à l'origine trouvés par un élève
# grâce à deux points A et B sont corrects.
# Le programme teste les deux points comme image et antécédent de la fonction affine définie avec a et b
#
#
a=float(input("quel est le coeff dir de la droite ?"))
b=float(input("quel est l'ordonnée à l'origine ?"))

def fnaffine(x):
    return a*x+b


xA=float(input("abscisse du premier point à tester ?"))
yA=float(input("ordonnée du premier point à tester ?"))

xA=round(xA,2)
yA=round(fnaffine(xA),2)

print("le résultat", fnaffine(xA))
print("l'ordonnée du point à tester",yA)

if fnaffine(xA)==yA:
    print("c'est juste !")
    xB=float(input("abscisse du deuxième point à tester ?"))
    yB=float(input("ordonnée du deuxième point à tester ?"))
    xB=round(xB,2)
    yB=round(fnaffine(xB),2)
    if fnaffine(xB)==yB:
        print("c'est juste juste !!")
    else :
        print("tu as fais une erreur ! Ce deuxième point n'appartient pas à la droite")

else :
    print("le point n'appartient pas à la droite")



# data[].attributes.body
Utilisation if et while.
aide résolution possible
test coefficient directeur
test ordonnée à l'origine
tracé

# data[].attributes.attachment_link.readable_text
def pluspetit(a,c):
    if a>c:
        (a,c)=(c,a)
    return
    
    
    
#déclaration des variables
coef=float()
m=float()
ordorigin=float()
F=str()
G=str()
c=float()

#initialisation
a=float(input("saisir l'abscisse du premier point : "))
b=float(input("saisir l'ordonnée du premier point : "))
c=a
while c==a:
    print(" attention ta droite n'aura pas de coefficient directeur si les deux points ont la meme abscisse !!!!")
    c=float(input("saisir l'abscisse du deuxième point : "))
d=float(input("saisir l'ordonnée du deuxième point : "))
A=[a,b]
B=[c,d]
assert(a!=c)

n=(B[1]-A[1])/(B[0]-A[0])
m=round(n,2)
t=A[1]-m*A[0]
p=round(t,2)
coef=0
ordorigin=0  


# Vérification du coefficient directeur
while m!=coef:
    coef=float(input("quel est le coefficient directeur de la droite?  "))
    coef=round(coef,2)
    if m*coef<0:
        print("vérifie le signe de ton coefficient directeur ")
    else:
        if m!=coef:
            print("ton résultat est incorrect, revérifie tes calculs")
            print("") 
            F=str(input(("veux tu oui(o) ou non(n) de l'aide ?")))
            if F=="o":
                print("difference des ordonnée divisé par difference des abscisses") 
print("bravo tu sais calculer un coefficient directeur d'une droite")        


        
        
#Vérification de l'ordonnée à l'origine
while p!=ordorigin:
    ordorigin=float(input("quel est l'ordonnée à l'origine de la droite?  "))
    ordorigin=round(ordorigin,2)
    if p*ordorigin<0:
        print("le point d'ordonnée à l'origine est il sous ou au dessus de l'axe des abscisses")
    else :
        if p!=ordorigin:
            print("ton résultat est incorrect, revérifie tes calculs") 
            print("")
            G=str(input(("veux tu oui(o) ou non(n) de l'aide ?")))
            if G=="o":
                print("b=y-a*x")  
print("bravo tu sais calculer une ordonnée à l'origine")
print("")
print("L'équation trouvée est y=",n,"x+",t)
print("voici sa représentation graphique :")




#représentation graphique
import matplotlib.pyplot as plt
import numpy as np
plt.close()
plt.title("droite de modélisation")
plt.xlabel("abscisses")
plt.ylabel("ordonnées")
plt.grid()
plt.plot(a,b,'rx')
plt.plot(c,d,'rx')
pluspetit(a,c)
x=np.linspace(a-2,c+2,100)
y=n*x+t
plt.plot(x,y)
plt.show()



    