व्युत्पन्न टावर्स और वेक्टर-स्पेस पैकेज (हैकसेल) का उपयोग कैसे करें

Question

मैं कुछ समय से हास्केल के साथ काम कर रहा हूं, लेकिन मैं एक विशेषज्ञ होने से बहुत दूर हूं। लेकिन मुझे लगता है कि प्रोग्रामिंग के लिए कार्यात्मक दृष्टिकोण मुझे सबसे अच्छा लगा।

अब तक मैं किसी भी गंभीर सामग्री की गणना करने के लिए एक परियोजना पर काम कर रहा हूं, जैसे किसी दिए गए ढांचे से धाराओं और संभावित विकिरण।

मैंने Conal Elliott द्वारा लिखे गए ब्लॉग का अनुसरण किया (यहां कुछ और Linear Maps है) जो बहुत अच्छा और मौलिक है।

दुर्भाग्य से, मैं एक साधारण उदाहरण :)

अधिक सटीक होना कमी कर रहा हूँ, मैं एक वक्र

f:[0,1] in R -> R³ 
t -> a*e_y + 2*t*e_z 

, जिस पर एक सरल सीधी रेखा है (0, एक, 2 * टी) है । जब मैं एफ के व्युत्पन्न की गणना करना चाहता हूं, उदा। वक्र की लंबाई के लिए, मुझे गणितीय परिणाम पता है, जो काफी सरल है (0,0,2), लेकिन मैं इसे हास्केल में कैसे पूरा कर सकता हूं, खासकर vector-space पैकेज के साथ?

मैं वास्तव में अपनी कार्यक्षमता की वजह से इस लाइब्रेरी का उपयोग करना चाहते हैं, यह वास्तव में दृष्टिकोण मैं भी ले

क्या मैं अब तक इस (लेकिन मुझे लगता है कि अब तक हास्केल सड़क पर आगे नहीं कर रहा हूँ) के लिए होता है :

{-# LANGUAGE Rank2Types, TypeOperators, FlexibleContexts, TypeFamilies #-} 
{-# OPTIONS_GHC -Wall #-} 
import Numeric.GSL.Integration 
import Data.VectorSpace 
import Data.Basis 
import Data.Cross 
import Data.Derivative 
import Data.LinearMap 

type Vec3 s = Three s 

prec :: Double 
prec = 1E-9 

f1 :: (Floating s, VectorSpace s, Scalar s ~ s) => s -> s 
f1 = id 

c1 :: Double -> Vec3 Double 
c1 = \t -> linearCombo [((v 0 0 1),f1 t),((v 0 1 0),2)] 

derivC :: Double -> Vec3 (Double :> Double) 
derivC t = c1 (pureD t) 

यह pureD समारोह के वास्तविक क्रियान्वयन, अब तक कुछ भी नहीं है कि मैं काम करता है इस स्निपेट संकलित करने के लिए प्राप्त करने की कोशिश की है। मैं निम्नलिखित त्रुटि मिलती है:

tests.hs:26:12: 
    Couldn't match expected type `Double :> Double' 
       with actual type `Double' 
    Expected type: Vec3 (Double :> Double) 
    Actual type: Vec3 Double 
    In the return type of a call of `c1' 
    In the expression: c1 (pureD t) 
Failed, modules loaded: none. 

वहाँ भी जो वेक्टर अंतरिक्ष का उपयोग करता है और वहाँ एक फूल की कुर्सी, जहां pureD प्रयोग किया जाता है पर भी एक उदाहरण है एक ग्राफिक्स पुस्तकालय है। मैंने उदाहरण को कम करने की कोशिश की लेकिन मुझे नहीं पता कि मैं इसे अपनी समस्या के लिए कैसे मैप कर सकता हूं।

किसी भी मदद की सराहना की जाएगी।

अग्रिम धन्यवाद

पुनश्च: मैं सभी लिंक मैं करना चाहते हैं पोस्ट नहीं कर सकते, लेकिन उपलब्ध कराने के लिए

Answer 1

एक दिलचस्प पुस्तकालय है कि .. साझा करने के लिए धन्यवाद के लिए तैयार हूँ। हालांकि मैं अभी तक पुस्तकालय की अवधारणा समझ में नहीं आता, कैसे इस कोड के बारे में: यह भी प्रयास करें gx =

{-# LANGUAGE Rank2Types, TypeOperators, FlexibleContexts, TypeFamilies #-} 
module Main where 

import Data.LinearMap 
import Data.Maclaurin 

diff :: (Double :~> (Double,Double,Double)) -> (Double :~> (Double,Double,Double)) 
diff f = \x -> (atBasis (derivative (f x))()) 

eval :: (Double :~> (Double,Double,Double)) -> Double -> (Double,Double,Double) 
eval f x = powVal (f x)   

f :: Double :~> (Double,Double,Double) 
f x = tripleD (pureD 0,pureD 1,(2*idD) x) 


*Main> map (eval f) [0,0.2 .. 1] 
[(0.0,1.0,0.0),(0.0,1.0,0.4),(0.0,1.0,0.8),(0.0,1.0,1.2000000000000002), 
(0.0,1.0,1.6000000000000003),(0.0,1.0,2.0000000000000004)] 

*Main> map (eval (diff f)) [0,0.2 .. 1] 
[(0.0,0.0,2.0),(0.0,0.0,2.0),(0.0,0.0,2.0),(0.0,0.0,2.0),(0.0,0.0,2.0), 
(0.0,0.0,2.0)] 

*Main> map (eval (diff $ diff f)) [0,0.2 .. 1] 
[(0.0,0.0,0.0),(0.0,0.0,0.0),(0.0,0.0,0.0),(0.0,0.0,0.0),(0.0,0.0,0.0),(0.0,0.0,0.0)] 

तीन गुना (0 pureD, आयोडीन अल्पता विकार एक्स, (आयोडीन अल्पता विकार * आयोडीन अल्पता विकार) एक्स) (जो लगते हैं वक्र का प्रतिनिधित्व करें (0, एक्स, एक्स^2))।

Answer 2

आप ad पैकेज को आजमा सकते हैं, जो पारदर्शी idiomatic Haskell में लिखे कार्यों के स्वचालित भेदभाव को आसान बनाने के लिए सबसे अच्छा है।

$ cabal install ad 
$ ghci 
Prelude> :m + Numeric.AD 
Prelude Numeric.AD> diffF (\t->let a=3 in [0,a,2*t]) 7 
[0,0,2] 
Prelude Numeric.AD> let f t = let a=3 in [0,a,2*t] 
Prelude Numeric.AD> diffF f 17 
[0,0,2]