Transformer le code Java en code Clojure rapide

Question

Ce code Java peut-il être traduit en un code Clojure aussi rapide ou presque aussi rapide?

J'ai pu obtenir des fonctions plus simples comme l'ajout de deux tableaux pour fonctionner à des vitesses raisonnables avec indication de type, mais je ne pouvais pas faire fonctionner Clojure comme le font les fonctions ci-dessous dans un laps de temps raisonnable Java interop ou Incanter matrices et en utilisant des styles fonctionnels ou impératifs. Est-ce que je manque quelque chose à propos de l'indication de type ou est-il préférable de faire ce genre de chose en Java?

static double[][] grad2_stencil= { {0,0,-1,0,0}, 
          {0,0,16,0,0}, 
          {-1,16,-60,16,-1}, 
          {0,0,16,0,0}, 
          {0,0,-1,0,0} }; 

public static double grad2(double[][] array, int x, int y){ 
    double temp=0; 
    int L=array.length; 
    for(int i=0; i<5; i++){ 
     for(int j=0; j<5; j++){ 
      temp+=array[((x+i-2)%L+L)%L][((y+j-2)%L+L)%L]*grad2_stencil[i][j]; 
     } 
    } 
    return temp/12.0; 
} 

public static double[][] grad2_field(double[][] arr){ 
    int L=arr.length; 
    double[][] result=new double[L][L]; 

    for(int i=0; i<L; i++){ 
     for(int j=0; j<L; j++){ 
      result[i][j]=grad2(arr, i, j); 
     } 
    } 

    return result; 
} 

Answer 1

commençant par la branche clojure 1.3 actuellement sur github vous pouvez use primitives as arguments to functions et retours de fonctions. Vous n'aurez plus à taper les primitives de nombre d'indices. Il devrait vraiment faire allusion à ce type de code beaucoup plus rapide et regarder beaucoup plus élégant. Dans l'indication de type cela, vous pourriez être confronté au fait que (< = clojure 1.2) tous les arguments de la fonction ont été encadrés.

Answer 2

L'autre élément qui aidera (également en 1.3) est la liaison de fonction statique, qui va faire certains appels de fonction aussi vite que les appels de méthode (ceci est également décrit dans le lien Arthur posté). Il sera toujours difficile d'écrire ce code d'une manière vraiment idiomatique (c'est-à-dire en utilisant la fonction d'ordre supérieur "map") pour des performances Java complètes, car les fonctions d'ordre supérieur ne pourront pas utiliser les fonctions statiques. la liaison, mais (avertissement d'un bouchon sans vergogne) c'est quelque chose Rich Hickey veut rectifier:

http://combinate.us/clojure/2010/09/27/clojure/

Answer 3

Effectuez les opérations suivantes dans clojure 1.3 (branche principale):

(def ^"[[D" grad2-stencil 
    (into-array (Class/forName "[D") 
    (map double-array 
     [[ 0 0 -1 0 0 ] 
     [ 0 0 16 0 0 ] 
     [-1 16 -60 16 -1 ] 
     [ 0 0 16 0 0 ] 
     [ 0 0 -1 0 0 ]]))) 

(defn ^:static idx ^long [^long x ^long i ^long L] 
    (-> x 
    (+ i) 
    (- 2) 
    (mod L) 
    (+ L) 
    (mod L))) 

(defn ^:static grad2 ^double [^doubles arr ^long x ^long y] 
    (let [L (alength arr) 
     temp (loop [i 0 j 0 temp 0.0] 
       (if (< i 5) 
       (let [a (idx x i L) 
         b (idx y j L) 
         temp (double (* (aget arr a b) 
             (aget grad2-stencil i j)))] 
        (if (< j 4) 
        (recur i (inc j) temp) 
        (recur (inc i) 0 temp))) 
       temp))] 
    (/ temp 12.0))) 

(defn ^:static grad2-field ^"[[D" [^"[[D" arr] 
    (let [result (make-array Double/TYPE (alength arr) (alength arr))] 
    (loop [i 0 j 0] 
     (when (< i 5) 
     (aset result (grad2 arr i j) i j) 
     (if (< j 4) 
      (recur i (inc j)) 
      (recur (inc i) 0)))) 
    result))