Convertir código Java en código Clojure rápido

Question

¿Se puede traducir este código Java a código Clojure que sea tan rápido o casi tan rápido?

He podido obtener funciones más simples como agregar dos matrices para ejecutar a velocidades razonables con insinuación de tipo, pero no pude hacer que Clojure hiciera lo que las siguientes funciones hacen en un tiempo razonable usando cualquiera Matrices Java interop o Incanter y utilizando estilos funcionales o imperativos.

¿Me falta algo sobre el tipo de alusión o es simplemente lo mejor para hacer este tipo de cosas 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

empezando por la rama 1.3 clojure actualmente en github que pueda use primitives as arguments to functions y retornos de funciones. Tampoco tendrá que escribir las primitivas del número de sugerencia. Realmente debería hacer sugerencias sobre este tipo de código mucho más rápido y parecer mucho más elegante.

En este tipo dando a entender que podría funcionar con el hecho de que (= < clojure 1.2) todos los argumentos de la función fueron encajonados.

Answer 2

La otra pieza que ayudará (también en 1.3) es la vinculación de funciones estáticas, que hará que algunas llamadas a funciones sean tan rápidas como las llamadas a métodos (esto también se describe en el enlace publicado por Arthur).

Todavía será difícil escribir este código de una manera verdaderamente idiomática (es decir, usando la función de orden superior "mapa") por ahora con un rendimiento completo de java, ya que las funciones de orden superior no podrán usar estática la vinculación, pero (descarada testigo de control) esto es algo Rich Hickey quiere rectificar:

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

Answer 3

intente lo siguiente en clojure 1.3 (rama principal):

(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))