F #: Aplicación parcial y cálculo previo

Question

En cuanto a una función en mi código de hoy, me preguntó si era posible combinar combinación parcial y optimización:

let foo (X:float) y1 y2 dx = 
    y1 + (y2 - y1) * dx/X 

Básicamente, la mera aplicación de una relación - por lo que los tres primeros parámetros son generalmente los mismos dentro de un bucle dado.

pensé que tal vez si yo acabo de hacer esto:

let foo2 (X:float) y1 y2 dx = 
    let dy = (y2 - y1)/X 
    y1 + dy * dx 

F # obtendría inteligente y optimizar para mí cuando parcialmente aplicar los tres primeros parámetros, pero el modo de depuración que no parece ser el caso (aunque no estoy seguro de haberlo probado de la manera correcta).

La pregunta es, ¿debería funcionar? Y si no, ¿hay una forma mejor de hacerlo (aparte de simplemente escribir otra función con dos parámetros)?

Answer 1

Creo que la mayoría de tales 'optimizaciones mágicas' requerirían 'análisis de efectos' que solo hace el mítico 'compilador suficientemente inteligente'.

Ponder esto:

let Expensive x y = 
    printfn "I am a side-effect of Expensive" 
    x + y // imagine something expensive 

let F x y z = 
    let tmp = Expensive x y 
    z + tmp 

printfn "Least chance of magic compiler optimization" 
for i in 1..3 do  
    F 3 4 i 

printfn "Slightly better chance" 
let Part = F 3 4 
for i in 1..3 do  
    Part i 

printfn "Now for real" 
let F2 x y = 
    let tmp = Expensive x y 
    (fun z -> z + tmp) 

printfn "Of course this still re-does it" 
for i in 1..3 do  
    F2 3 4 i 

printfn "Of course this finally saves re-do-ing Expensive" 
let Opt = F2 3 4 
for i in 1..3 do  
    Opt i 

(* output 

Least chance of magic compiler optimization 
I am a side-effect of Expensive 
I am a side-effect of Expensive 
I am a side-effect of Expensive 
Slightly better chance 
I am a side-effect of Expensive 
I am a side-effect of Expensive 
I am a side-effect of Expensive 
Now for real 
Of course this still re-does it 
I am a side-effect of Expensive 
I am a side-effect of Expensive 
I am a side-effect of Expensive 
Of course this finally saves re-do-ing Expensive 
I am a side-effect of Expensive 

*)  

El punto es, la semántica del lenguaje respecto a los efectos requerir el compilador se comporte exactamente como esta, a menos que 'caro' no tiene ningún efecto y el compilador es realmente muy inteligente y puede descubrir que por sí mismo.

Answer 2

No me sorprende que aparentemente no haya nada diferente en el modo de depuración. ¿Por qué no hace realmente N repeticiones de N (#time;; en el indicador interactivo F #)?

En cuanto a su esperanza de compartir el cálculo común para valores fijos de todos, pero dx, intente esto:

let fdx = foo2 X y1 y2 
for dx in dxes do 
    fdx dx 

Es decir, FDX es la aplicación parcial. Almacenarlo explícitamente fuera del ciclo me hace esperar más del optimizador.

Al menos en el mensaje interactivo (no creo que se realice una optimización completa allí, ¿no?) Parece que mi sugerencia es solo un 15% de aceleración (es raro que haya una aceleración, porque definitivamente repite el cuerpo completo de foo2). Hacer esto es mucho más rápido:

let fdx = foo3 X y1 y2 
for dx in dxes do 
    fdx dx 

Dónde foo3 es (de Benjlol):

let foo3 (X:float) y1 y2 = 
    let dy = (y2 - y1)/X 
    (fun dx -> y1 + dy * dx) 

Tenga en cuenta que sólo usar foo3 como una función 4 argumento en el bucle es dos veces tan lento como foo2, pero el almacenamiento la aplicación parcial fuera del ciclo, es 3 veces más rápido.

Answer 3

(Esto se putear no la reputación, la verdad es que no había pensado en esto cuando empecé a hacer mi pregunta)

Aquí hay una solución que he llegado con, no está seguro de si es la mejor:

let foo3 (X:float) y1 y2 = 
    let dy = (y2 - y1)/X 
    (fun dx -> y1 + dy * dx) 

Funciona mucho más rápido.