La dérivée partielle en Python

Je suis en train de déplacement de C pour Python. Cette fois, j'ai besoin de calculer les dérivées partielles numériquement à partir d'une grille donnée. Je sais comment le faire en C, donc pour le moment je viens de l'utiliser inline adaptateur, c'est à dire

def dz(x,X,Y,Z,dx):
    y = numpy.zeros((X,Y,Z), dtype='double');
    code = """
            int i, j, k;
            for (i=0; i<X-1; i++){
                for(k=0; k<Y; k++){
                    for (j=0; j<Z; j++){
                        y[i,k,j] = (x[i+1, k, j] - x[i, k, j])/dx;
                        }
                    }
                }
            for (j=0; j<Z; j++){
                for(k=0; k<Y; k++){
                    y[X-1,k,j] = - x[X-1, k, j]/dx;
                    }
                }
        """
    weave.inline(code, ['x', 'y', 'dx', 'X', 'Y', 'Z'], \
                type_converters=converters.blitz, compiler = 'gcc');
    return y;

où x et y 3D tableaux numpy, comme vous pouvez le voir, et la deuxième boucle est synonyme de conditions aux limites. Bien sûr, je peux appliquer la même logique en pur Python, mais le code serait inefficace. Je me demande, cependant, si il est possible de calculer une dérivée partielle à l'aide de pure numpy? Je vous serais reconnaissant de toute aide quelqu'un peut fournir.

Pourquoi vous embêter à passer de C à Python si vous êtes juste de l'écrire C et Python exécuter (inefficace)?
Si vous avez affaire à des Équations aux dérivées partielles, FEniCS (fenicsproject.org/documentation/tutorial/index.html) qui pourrait être intéressant pour vous
X, Y, Z veux dire? la forme de x?
Qui est-il: je voudrais changer de pur Python, le truc est, la mise en Œuvre actuelle j'ai, c'est la manière la plus rapide que je peux faire, même si, j'en suis sûr, une pure numpy solution existe. Cependant, vous avez raison: avec la solution que j'ai en ce moment, il n'y a pas de sens dans le passage à Python.
Ouais, juste les dimensions.

OriginalL'auteur Eugene B | 2014-07-22

  1. 4

    np.diff peut-être la plus idiomatique numpy façon de le faire:

    y = np.empty_like(x)
y[:-1] = np.diff(x, axis=0) / dx
y[-1] = -x[-1] / dx

    Vous pourriez également être intéressé par np.dégradé, bien que cette fonction prend le gradient sur toutes les dimensions du tableau d'entrée plutôt qu'un seul.

    OriginalL'auteur ali_m

  2. 2

    Si vous utilisez numpy, ce qui devrait faire la même chose que votre code ci-dessus:

    y = np.empty_like(x)
y[:-1] = (x[1:] - x[:-1]) / dx
y[-1] = -x[-1] / dx

    Pour obtenir le même résultat au cours de la deuxième axe, vous feriez:

    y = np.empty_like(x)
y[:, :-1] = (x[:, 1:] - x[:, :-1]) / dx
y[:, -1] = -x[:, -1] / dx

    OriginalL'auteur Jaime

  3. 2
    def dz(x,dx):
    y = numpy.zeros(x.shape, dtype='double')
    y[:-1] = (x[1:] - x[:-1]) / dx
    y[-1]  = -x[-1] / dx
    return y

    OriginalL'auteur Joris van Rantwijk