Discussion :

[marie bioch]

bonjour, je suis étudiante en biologiste et j'ignore tout ce qui concerne la programmation surtout python et il y a un travail quand doit rendre je voulais le posté ici pour avoir de l'aide merci beaucoup de m'aider à faire ce devoir:

Le but de ce travail est de dériver un « plan moyen » passant par N points. Vous
aurez à résoudre ce problème de 2 manières :
1. En programmant l’ensemble de l’approche en python en utilisant « numpy ».
2. En vous appuyant sur le module « numpy.linalg.lstsq ».
Dans tous les cas n’oubliez pas qu’il faudra décider comment vous allez exprimer votre plan :
1. x=f(y, z) et l’écriture du plan sera : -x + l*y + m*z + n =0
2. y=f(x, z) et l’écriture du plan sera : l*x - y + m*z + n =0
3. z=f(x, y) et l’écriture du plan sera : l*x + m*y - z + n =0
Je vous rappelle que nous avons défini les dx, dy, dz et que le plus grand des 3 en valeur absolu est sélectionné pour l’expression de l’équation du plan de manière non
ambiguë.
Par exemple, si |dx| est le maximum, c’est donc la description x=f(y,z)
Il vous faut choisir la bonne description car si vous choisissez toujours la même, par exemple
z=f(x,y) vous ne pourrez pas exprimer tous les plans avec cette description.
Ainsi le plan P : x=20, c'est-à-dire l=1 (la lettre ell), m=0, n=-20 mais dans cette équation
l*x + m*y - z + n =0, le coefficient de z est égal à -1, donc le plan P : x=20, ne peut pas
être exprimé avec la description z=f(x,y) !!!
Pour la partie programmation du plan moyen en python :
la classe aura:
a. pour déclaration :
class PlaneAverage(Plane):
b. comme méthode __init__() :
def __init__(self, points): #points contenant les points 3D
c. comme méthode pour calculer le plan moyen :
def average(self): # cette méthode évalue les Sx,Sy, Sz
# ainsi que Sxx, Syy, Szz, Sxy,Sxz,Syz
# puis les dxy, dxz, dyz, dxx, dyy, dzz
# puis les dx, dy,dz
# ... à vous pour la suite !!!
d. une méthode statique pour calculer le plan en z=f(x,y) par exemple :
# @classmethod avec cls a la place de self
@staticmethod
def planEnZ(dz, dxx, dyy, dxy, dxz, dyz, S, Sz, Sx, Sy):
2
Vous n’êtes pas obligé d’écrire les fonctions statiques « planEnX() », « planEnY() » car il
suffit de comparer x=f(y, z) à z=f(x, y) pour observer que pour x=f(), x joue le rôle de z, y
joue le rôle de x, z joue le rôle de y dans l’expression z=f().
Donc pour calcule x=f(y, z) il suffit d’appeler la méthode statique avec l’échange des
variables suivants:
z=f(x, y) : planEnZ(dz, dxx, dyy, dxy, dxz, dyz, S, Sz, Sx, Sy)
plan en Z
x=f(y, z) : planEnZ(dx, dyy, dzz, dyz, dxy, dxz, S, Sx, Sy, Sz)
plan en X
y=f(x, z) : planEnZ(dy, dxx, dzz, dxz, dxy, dyz, S, Sy, Sx, Sz)
plan en Y

[wiztricks]

Salut,

bonjour, je suis étudiante en biologiste et j'ignore tout ce qui concerne la programmation surtout python et il y a un travail quand doit rendre je voulais le posté ici pour avoir de l'aide merci beaucoup de m'aider à faire ce devoir

Si vous demandez dans un forum de passionnés de programmation dans le langage X de vous expliquer comment faire fonctionner un bout de code ou de comprendre des concepts de programmation dans ce langage là, nombreux seront ceux qui essaieront de vous aider.
Si vous arrivez en disant je n'y comprend rien, çà ne m'intéresse pas plus que çà mais j'aimerai bien qu'on fasse le boulot à ma place parce que devoir à rendre, pas grand monde vous aidera.

- W

[marie bioch]

je suis vraiment désolé si vous m'avais pas bien compris moi je fais pas de la programmation et c'est pas mon domaine, j'ai quand même essayer mais je connais pas les règle de club, je savais pas que je dois écrire ce que j'ai déjà fais voila ce que j'ai réussie à faire et j'ai juste demander de l'aide crois moi ça fais une quinzaine de jours que j'essaie de le faire maintenant si vous pouvez pas m'aider c'est pas grave
voilà ce que j'ai fais j'ai exécuté ça marche normalement mais pour le reste je bloque :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
import trigo
import math
import numpy as np
class Plane(object):
    def __init__(self, a, b, c=None, d=None):
        if c !=None :
            if d != None :
                self._planeFromABCD(a,b,c,d)
            else :
                self._planeFrom3Points(a,b,c)
        else :
            self._planeFromVectorPoint(a, b)
 
    def _planeFromABCD(self, a, b,c,d):
        self._plane=[a, b, c, d]
 
    def _planeFrom3Points(self, a, b, c):
        u=[a[i]- b[i] for i in range(len(a))]
        v=[c[i]- b[i] for i in range(len(c))]
        w=trigo.vdot(u,v)
        return self.__planeFromVectorPoint(w, a)
 
 
    def _planeFromVectorPoint(self, v, p):
        self._plane=v+[-trigo.dot(v,p)]
 
    def __str__(self):
        plane=self._plane
        return "<{:8.3f},{:8.3f},{:8.3f},{:8.3f}>".format(
                plane[0], plane[1], plane[2], plane[3])
 
    def normalize(self):
        nn=self.norm()
        return [self._plane[i]/nn for i in range(4)]
 
    def norm(self):
        from math import sqrt
        return sqrt(sum([self._plane[i]*self._plane[i] for i in range(3)]))
 
    def perpendicular(self):
        return self._plane[:3]
 
    def distance(self, point):
        plane=self._plane
        return plane[0]*point[0]+plane[1]*point[1]+plane[2]*point[2]+plane[3]
 
    def check(self, points):
        print "check distance to plane"
        for v in points:
            dist=self.distance(v)
            print v, dist
 
if __name__ == "__main__":
    p1=Plane([1,0,0], [1,1,1])
    print "p1", p1
 
    p=Plane(1,2,0,2)
    print "p:", p
    print "norme de p:", p.norm()
    print "perpendiculaire a p:", p.perpendicular()
    print "p normalise",p.normalize()
 
et là une partie donnée qu'on doit intégré mais j'ai pas réussie à faire ça 
 
# 
import trigo
import math
from plane import Plane
class PlaneMock(Plane):
    def __init__(self, plane, delta=0.01, max=1000.):
        Plane.__init__(self, *plane._plane)
        self._points=None
        self._N=Npoints
        self._max=max
        self._delta=delta
 
    def generate(self, N=100):
        """generate the points randomly"""
        if self._points :
            return self._points
        import random as rd
        index=[[0,1,2], [1,0,2], [2, 0, 1]]
        points=[]
        plane=self._plane
        #trouver le plus grand en valeur abs() a, b, c du plan P(x)=ax+by+cz+d
        #et on calcul alors x=(-by-cz-d)/a si c'est a
        dabc=[math.fabs(plane[0]), math.fabs(plane[1]), math.fabs(plane[2])]
        mx=max(dabc)
        #idx contient l'indice pour le plan 0:x; 1:y et 2:z
        idx=dabc.index(mx)
 
        plane =[val/plane[idx] for val in plane]
        print "    plane", plane, index[idx]
        [idx0, idx1, idx2]=index[idx]
 
        for j in xrange(self._N):
            v=[0,0,0]
            r=rd.random()
            v[idx1]=self._max*(2*r-1.0)
            r=rd.random()
            v[idx2]=self._max*(2*r-1.0)
            v[idx0]=-(plane[idx1]*v[idx1] + plane[idx2]*v[idx2] + plane[3])
            for k in xrange(3):
                v[k] +=rd.uniform(-self._delta, self._delta)
            points.append(v)
        self._points=points
 
        return points
 
    def __str__(self):
        super(PlaneMock,self).__str__()
 
if __name__ == "__main__":
    p1=Plane([1,0,0], [1,1,1])
    print "p1", p1
 
    p=Plane(1,2,0,2)
    print "p:", p
    print p.norm()
    print p.perpendicular()
    print p.normalize()
    print p
    mp=PlaneMock(p, 10, delta=0.01)
    lst=mp.generate()
    print lst
    mp.check(lst)

[VinsS]

Salut,

Ça a l'air correct, où se situe exactement le problème ?

Quelques détails, mets les imports (sqr et random) en début de code, pas dans les fonctions.

Et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
# Ceci:
sqrt(sum([self._plane[i]*self._plane[i] for i in range(3)]))
 
# est la même chose que ça:
sqrt(sum([i**2 for i in self._plane])

[marie bioch]

merci beaucoup pour l'aide, voilà la partie que j'arrive pas à faire :
Pour la partie programmation du plan moyen en python :
la classe aura:
a. pour déclaration :
class PlaneAverage(Plane):
b. comme méthode __init__() :
def __init__(self, points): #points contenant les points 3D
c. comme méthode pour calculer le plan moyen :
def average(self): # cette méthode évalue les Sx,Sy, Sz
# ainsi que Sxx, Syy, Szz, Sxy,Sxz,Syz
# puis les dxy, dxz, dyz, dxx, dyy, dzz
# puis les dx, dy,dz
# ... à vous pour la suite !!!
d. une méthode statique pour calculer le plan en z=f(x,y) par exemple :
# @classmethod avec cls a la place de self
@staticmethod
def planEnZ(dz, dxx, dyy, dxy, dxz, dyz, S, Sz, Sx, Sy):
2
Vous n’êtes pas obligé d’écrire les fonctions statiques « planEnX() », « planEnY() » car il
suffit de comparer x=f(y, z) à z=f(x, y) pour observer que pour x=f(), x joue le rôle de z, y
joue le rôle de x, z joue le rôle de y dans l’expression z=f().
Donc pour calcule x=f(y, z) il suffit d’appeler la méthode statique avec l’échange des
variables suivants:
z=f(x, y) : planEnZ(dz, dxx, dyy, dxy, dxz, dyz, S, Sz, Sx, Sy)
plan en Z
x=f(y, z) : planEnZ(dx, dyy, dzz, dyz, dxy, dxz, S, Sx, Sy, Sz)
plan en X
y=f(x, z) : planEnZ(dy, dxx, dzz, dxz, dxy, dyz, S, Sy, Sx, Sz)
plan en Y

[marie bioch]

Bonjour, svp comment faire pour dériver un plan moyen qui passe sur N point en programment sur python et en utilisant « numpy »?.
avec une des écriture suivante :

x=f(y, z) et l’écriture du plan sera : -x + l*y + m*z + n =0
y=f(x, z) et l’écriture du plan sera : l*x - y + m*z + n =0
z=f(x, y) et l’écriture du plan sera : l*x + m*y - z + n =0

et comme méthode pour calculer le plan moyen :

def average(self): # cette méthode évalue les Sx,Sy, Sz
# ainsi que Sxx, Syy, Szz, Sxy,Sxz,Syz
# puis les dxy, dxz, dyz, dxx, dyy, dzz
# puis les dx, dy,dz
# .....

[wiztricks]

Salut,

Bonjour, svp comment faire pour dériver un plan moyen qui passe sur N point en programment sur python et en utilisant « numpy »?.

Comme pas grand monde est allé aux mêmes cours que vous, pas facile de comprendre l'énoncé du problème. C'est juste un tas de termes et de symboles qui sortent du néant! Et si on ne comprends pas l'énoncé, on ne va pas pouvoir faire grand chose côté "programmation".

- W