úÎ!&62ÿq      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€ ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ ‘ ’ “ ” • – — ˜ ™ š › œ Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ğ Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü İ Ş ß à á â ã ä å æ ç è é ê ë ì í î ï ğ ñ ò ó ô õ ö ÷ øùúûüışÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw x y z { | } ~  €  ‚ ƒ „ …†‡ˆ‰Š‹Œ‘’“”•–—˜™š›œŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏĞÑÒÓÔÕÖ×ØÙÚÛÜİŞßàáâãäåæçèéêëìíîïğñòóôõö÷øùúûüışÿ         ! " # $ % & ' ( ) * +,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm n o p "!(c) Edward Kmett 2010-2019BSD3ekmett@gmail.com experimentalGHC onlyNoneM!q(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlySafe12>UVX("rad3Used to sidestep the need for UndecidableInstances.adA C is a tower of all (higher order) partial derivatives of a functionAt each step, a  f& is wrapped in another layer worth of f. )a :- f a :- f (f a) :- f (f (f a)) :- ...adTake the tail of a .adTake the head of a .ad Construct a  by unzipping the layers of a s Comonad.3(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone=>?@ACHMSVX/  adjallowed to return False for items with a zero derivative, but we'll give more NaNs than strictly necessary adPallowed to return False for zero, but we give more NaN's than strictly necessaryadEmbed a constantadScalar-vector multiplicationadVector-scalar multiplicationadScalar divisionad  = lift 0   777(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone8=>?@ACHMSVX2s#ad#C is useful for defining new AD primitives in a fairly generic way.#$(%&')*#$(%&')*None2HMV3+,-+,-(c) Edward Kmett 2015BSD3ekmett@gmail.com experimentalGHC onlyNone &'2>HV5º=ad>The choice between two AD modes is an AD mode in its own right =?>@ABCDEFGH =?>CBDE@AFGH(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone 12>HMUV8ÀXad>The composition of two AD modes is an AD mode in its own rightXYZXYZ(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone 2=>?@AHMV:|hijklmnhijklmn"(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNoneAàtadZip a u f with a v g assuming f! has at least as many entries as g.wadZip a u f with a v g assuming f, using a default value after f is exhausted.xad"Used internally to define various y combinators.zad"Used internally to define various y combinators.{adaUsed internally to implement functions which truncate lists after the stream of results convergetwxz{ (c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone2=>?@AHSVXEW€adTower is an AD  B that calculates a tangent tower by forward AD, and provides fast diffsUU, diffsUF€‚ƒ„…†‡ˆ‰Š‹Œ€‚ƒ„…†‡Šˆ‰‹Œ|6 (c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone2=>?@ACHUVUĞ¥adúWe only store partials in sorted order, so the map contained in a partial will only contain partials with equal or greater keys to that of the map in which it was found. This should be key for efficiently computing sparse hessians. there are only  n + k - 1 choose k? distinct nth partial derivatives of a function with k inputs.¹ad3The value of the derivative of (f*g) of order mi is } [a * µ (~ (¬ b) f) * µ (~ (¬ c) g) | (a,b,c) <- ¹ mi ]  It is a bit more complicated in V below, since we build the whole tree of derivatives and want to prune the tree with §_s as much as possible. The number of terms in the sum for order mi as of differentiation has } (€ (+1) as)X terms, so this is *much* more efficient than the naive recursive differentiation with 2^} as terms. The coefficients aX, which collect equivalent derivatives, are suitable products of binomial coefficients.Ÿ ¡¢£¤¥§¦¨©ª«¬­®¯°±²³´µ¶·¸¹¨©ª«¬¥§¦®­°±²¯´³¶·¸¡¢£¤Ÿ ¹µ6 (c) Edward Kmett 2012-2015BSD3ekmett@gmail.com experimentalGHC onlyNone&'2=>?@AHSVXf> ‚adµThis is used to create a new entry on the chain given a unary function, its derivative with respect to its input, the variable ID of its input, and the value of its input. Used by % and ( internally.ƒadThis is used to create a new entry on the chain given a binary function, its derivatives with respect to its inputs, their variable IDs and values. Used by ( internally.Üad^Helper that extracts the derivative of a chain when the chain was constructed with 1 variable.İadnHelper that extracts both the primal and derivative of a chain when the chain was constructed with 1 variable.„ad5Used internally to push sensitivities down the chain.ŞadDExtract the partials from the current chain for a given AD variable.ßad Return an … of Ş# given bounds for the variable IDs.àad Return an † of sparse partialsáad"Construct a tape that starts with n variables.ÎĞÏÑÒÓÔÕÖ×ÚØÙÛÜİŞßàáâãäåæçèÎĞÏÑÒÓÔÕÖ×ÚØÙáŞßàÜİäåçæèâãÛ(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone2=?@ACHSVXqäüadKahn is a  A using reverse-mode automatic differentiation that provides fast diffFU, diff2FU, grad, grad2 and a fast jacobianE when you have a significantly smaller number of outputs than inputs.şadA Tape\ records the information needed back propagate from the output to each input during reverse   AD.‡ad*back propagate sensitivities along a tape.adhThis returns a list of contributions to the partials. The variable ids returned in the list are likely not unique!ad Return an … of # given bounds for the variable IDs. ad Return an † of sparse partialsøùúûüışÿ     üışÿ   øùúû  None,=>?@AHVsk '()*+,-./012 '()*,+-./012(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone2=?@AHSVXvvBadB mode ADFadCalculate the F using forward mode AD.BDECFGHIJKLMNOBDECJFHGIKLMNO(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone2=>?@AHSVXx¢`acbdefg`acbdefg (c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone >@ACSX­RwadThe wk function calculates the gradient of a non-scalar-to-scalar function with reverse-mode AD in a single pass. grad (\[x,y,z] -> x*y+z) [1,2,3][2,1,1]grad (\[x,y] -> x**y) [0,2] [0.0,NaN]xadThe xv function calculates the result and gradient of a non-scalar-to-scalar function with reverse-mode AD in a single pass.!grad' (\[x,y,z] -> x*y+z) [1,2,3] (5,[2,1,1])yadw g fE function calculates the gradient of a non-scalar-to-scalar function ft with reverse-mode AD in a single pass. The gradient is combined element-wise with the argument using the function g. w == y (_ dx -> dx) ˆ == y ‰ zadx g fG calculates the result and gradient of a non-scalar-to-scalar function fs with reverse-mode AD in a single pass the gradient is combined element-wise with the argument using the function g. x == z (_ dx -> dx) {adThe {c function calculates the jacobian of a non-scalar-to-non-scalar function with reverse AD lazily in m passes for m outputs.$jacobian (\[x,y] -> [y,x,x*y]) [2,1][[0,1],[1,0],[1,2]]|adThe |b function calculates both the result and the Jacobian of a nonscalar-to-nonscalar function, using m# invocations of reverse AD, where m( is the output dimensionality. Applying fmap snd* to the result will recover the result of { | An alias for gradF'%jacobian' (\[x,y] -> [y,x,x*y]) [2,1][(1,[0,1]),(2,[1,0]),(2,[1,2])]}adR'jacobianWith g f' calculates the Jacobian of a non-scalar-to-non-scalar function f with reverse AD lazily in m passes for m outputs.kInstead of returning the Jacobian matrix, the elements of the matrix are combined with the input using the g. { == } (_ dx -> dx) } ‰ == (f x -> ‰ x Š f x) ~ad}W g f' calculates both the result and the Jacobian of a nonscalar-to-nonscalar function f, using m# invocations of reverse AD, where m( is the output dimensionality. Applying fmap snd* to the result will recover the result of }kInstead of returning the Jacobian matrix, the elements of the matrix are combined with the input using the g. | == ~ (_ dx -> dx)ad%Compute the derivative of a function. diff sin 01.0€adThe €Z function calculates the result and derivative, as a pair, of a scalar-to-scalar function. diff' sin 0 (0.0,1.0) diff' exp 0 (1.0,1.0)ad`Compute the derivatives of each result of a scalar-to-vector function with regards to its input.diffF (\a -> [sin a, cos a]) 0 [1.0,0.0]‚advCompute the derivatives of each result of a scalar-to-vector function with regards to its input along with the answer.diffF' (\a -> [sin a, cos a]) 0[(0.0,1.0),(1.0,0.0)]ƒadCompute the hessian via the jacobian of the gradient. gradient is computed in reverse mode and then the jacobian is computed in reverse mode.However, since the w f :: f a -> f ai is square this is not as fast as using the forward-mode Jacobian of a reverse mode gradient provided by  #.hessian (\[x,y] -> x*y) [1,2] [[0,1],[1,0]]„ad•Compute the order 3 Hessian tensor on a non-scalar-to-non-scalar function via the reverse-mode Jacobian of the reverse-mode Jacobian of the function.Less efficient than $%.;hessianF (\[x,y] -> [x*y,x+y,exp x*cos y]) [1,2 :: RDouble]r[[[0.0,1.0],[1.0,0.0]],[[0.0,0.0],[0.0,0.0]],[[-1.131204383757,-2.471726672005],[-2.471726672005,1.131204383757]]]Îwxyz{|}~€‚ƒ„Îwxyz{|}~ƒ„€‚(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNoneݶ…adCCompute the directional derivative of a function given a zipped up ‹* of the input values and their derivatives†adNCompute the answer and directional derivative of a function given a zipped up ‹* of the input values and their derivatives‡adMCompute a vector of directional derivatives for a function given a zipped up ‹+ of the input values and their derivatives.ˆadYCompute a vector of answers and directional derivatives for a function given a zipped up ‹+ of the input values and their derivatives.‰adThe ‰Y function calculates the first derivative of a scalar-to-scalar function by forward-mode AD diff sin 01.0ŠadThe ŠU function calculates the result and first derivative of scalar-to-scalar function by B mode AD Š Œ == Œ &'  Š f = f &' d f  diff' sin 0 (0.0,1.0) diff' exp 0 (1.0,1.0)‹adThe ‹N function calculates the first derivatives of scalar-to-nonscalar function by B mode ADdiffF (\a -> [sin a, cos a]) 0 [1.0,-0.0]ŒadThe Œ\ function calculates the result and first derivatives of a scalar-to-non-scalar function by B mode ADdiffF' (\a -> [sin a, cos a]) 0[(0.0,1.0),(1.0,-0.0)]adBA fast, simple, transposed Jacobian computed with forward-mode AD.ad2A fast, simple, transposed Jacobian computed with B mode AD) that combines the output with the input.adCompute the Jacobian using B mode AD%. This must transpose the result, so ( is faster and allows more result types.7jacobian (\[x,y] -> [y,x,x+y,x*y,exp x * sin y]) [pi,1]_[[0.0,1.0],[1.0,0.0],[1.0,1.0],[1.0,3.141592653589793],[19.472221418841606,12.502969588876512]]adCompute the Jacobian using B mode ADK and combine the output with the input. This must transpose the result, so ) is faster, and allows more result types.‘adCompute the Jacobian using B mode AD along with the actual answer.’adCompute the Jacobian using B mode ADW combined with the input using a user specified function, along with the actual answer.“ad9Compute the gradient of a function using forward mode AD.Note, this performs O(n) worse than () for n2 inputs, in exchange for better space utilization.”adDCompute the gradient and answer to a function using forward mode AD.Note, this performs O(n) worse than (* for n2 inputs, in exchange for better space utilization.•adCompute the gradient of a function using forward mode AD and combine the result with the input using a user-specified function.Note, this performs O(n) worse than (+ for n2 inputs, in exchange for better space utilization.–adCompute the gradient of a function using forward mode AD and the answer, and combine the result with the input using a user-specified function.Note, this performs O(n) worse than (, for n2 inputs, in exchange for better space utilization.gradWith' (,) sum [0..4]$(10,[(0,1),(1,1),(2,1),(3,1),(4,1)])—adRCompute the product of a vector with the Hessian using forward-on-forward-mode AD.˜adJCompute the gradient and hessian product using forward-on-forward-mode AD.B…†‡ˆ‰Š‹Œ‘’“”•–—˜B“”•–‘’—˜‰Š‹Œ…†‡ˆ(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNoneSX$™adCCompute the directional derivative of a function given a zipped up ‹* of the input values and their derivativesšadNCompute the answer and directional derivative of a function given a zipped up ‹* of the input values and their derivatives›adMCompute a vector of directional derivatives for a function given a zipped up ‹+ of the input values and their derivatives.œadYCompute a vector of answers and directional derivatives for a function given a zipped up ‹+ of the input values and their derivatives.adThe Y function calculates the first derivative of a scalar-to-scalar function by forward-mode + diff sin 01.0adThe U function calculates the result and first derivative of scalar-to-scalar function by B mode +  Œ == Œ &'   f = f &' d f  diff' sin 0 (0.0,1.0) diff' exp 0 (1.0,1.0)ŸadThe ŸN function calculates the first derivatives of scalar-to-nonscalar function by B mode +diffF (\a -> [sin a, cos a]) 0 [1.0,-0.0] adThe  \ function calculates the result and first derivatives of a scalar-to-non-scalar function by B mode +diffF' (\a -> [sin a, cos a]) 0[(0.0,1.0),(1.0,-0.0)]¡adBA fast, simple, transposed Jacobian computed with forward-mode AD.¢ad2A fast, simple, transposed Jacobian computed with B mode +) that combines the output with the input.£adCompute the Jacobian using B mode +%. This must transpose the result, so ¡( is faster and allows more result types.7jacobian (\[x,y] -> [y,x,x+y,x*y,exp x * sin y]) [pi,1]_[[0.0,1.0],[1.0,0.0],[1.0,1.0],[1.0,3.141592653589793],[19.472221418841606,12.502969588876512]]¤adCompute the Jacobian using B mode +K and combine the output with the input. This must transpose the result, so ¢) is faster, and allows more result types.¥adCompute the Jacobian using B mode + along with the actual answer.¦adCompute the Jacobian using B mode +W combined with the input using a user specified function, along with the actual answer.§ad9Compute the gradient of a function using forward mode AD.Note, this performs O(n) worse than () for n2 inputs, in exchange for better space utilization.¨adDCompute the gradient and answer to a function using forward mode AD.Note, this performs O(n) worse than (* for n2 inputs, in exchange for better space utilization.©adCompute the gradient of a function using forward mode AD and combine the result with the input using a user-specified function.Note, this performs O(n) worse than (+ for n2 inputs, in exchange for better space utilization.ªadCompute the gradient of a function using forward mode AD and the answer, and combine the result with the input using a user-specified function.Note, this performs O(n) worse than (, for n2 inputs, in exchange for better space utilization.gradWith' (,) sum [0..4]$(10,[(0,1),(1,1),(2,1),(3,1),(4,1)])«adRCompute the product of a vector with the Hessian using forward-on-forward-mode AD.¬adJCompute the gradient and hessian product using forward-on-forward-mode AD.+B™š›œŸ ¡¢£¤¥¦§¨©ª«¬+B§¨©ª£¥¤¦¡¢«¬Ÿ ™š›œNone [sin a, cos a]) 0 [1.0,-0.0]´adThe ´\ function calculates the result and first derivatives of a scalar-to-non-scalar function by Forward mode ADdiffF' (\a -> [sin a, cos a]) 0[(0.0,1.0),(1.0,-0.0)]µadBA fast, simple, transposed Jacobian computed with forward-mode AD.¶ad2A fast, simple, transposed Jacobian computed with Forward mode AD) that combines the output with the input.·adCompute the Jacobian using Forward mode AD%. This must transpose the result, so µ( is faster and allows more result types.7jacobian (\[x,y] -> [y,x,x+y,x*y,exp x * sin y]) [pi,1]_[[0.0,1.0],[1.0,0.0],[1.0,1.0],[1.0,3.141592653589793],[19.472221418841606,12.502969588876512]]¸adCompute the Jacobian using Forward mode ADK and combine the output with the input. This must transpose the result, so ¶) is faster, and allows more result types.¹adCompute the Jacobian using Forward mode AD along with the actual answer.ºadCompute the Jacobian using Forward mode ADW combined with the input using a user specified function, along with the actual answer.»ad9Compute the gradient of a function using forward mode AD.Note, this performs O(n) worse than () for n2 inputs, in exchange for better space utilization.¼adDCompute the gradient and answer to a function using forward mode AD.Note, this performs O(n) worse than (* for n2 inputs, in exchange for better space utilization.½adCompute the gradient of a function using forward mode AD and combine the result with the input using a user-specified function.Note, this performs O(n) worse than (+ for n2 inputs, in exchange for better space utilization.¾adCompute the gradient of a function using forward mode AD and the answer, and combine the result with the input using a user-specified function.Note, this performs O(n) worse than (, for n2 inputs, in exchange for better space utilization.gradWith' (,) sum [0..4]:(10.0,[(0.0,1.0),(1.0,1.0),(2.0,1.0),(3.0,1.0),(4.0,1.0)])'­®¯°±²³´µ¶·¸¹º»¼½¾'»¼½¾·¹¸ºµ¶±²³´­®¯°(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNoneSXk1¿adCCompute the directional derivative of a function given a zipped up ‹* of the input values and their derivativesÀadNCompute the answer and directional derivative of a function given a zipped up ‹* of the input values and their derivativesÁadMCompute a vector of directional derivatives for a function given a zipped up ‹+ of the input values and their derivatives.ÂadYCompute a vector of answers and directional derivatives for a function given a zipped up ‹+ of the input values and their derivatives.ÃadThe ÃY function calculates the first derivative of a scalar-to-scalar function by forward-mode + diff sin 01.0ÄadThe ÄU function calculates the result and first derivative of scalar-to-scalar function by Forward mode + Ä Œ == Œ &'  Ä f = f &' d f  diff' sin 0 (0.0,1.0) diff' exp 0 (1.0,1.0)ÅadThe ÅN function calculates the first derivatives of scalar-to-nonscalar function by Forward mode +diffF (\a -> [sin a, cos a]) 0 [1.0,-0.0]ÆadThe Æ\ function calculates the result and first derivatives of a scalar-to-non-scalar function by Forward mode +diffF' (\a -> [sin a, cos a]) 0[(0.0,1.0),(1.0,-0.0)]ÇadBA fast, simple, transposed Jacobian computed with forward-mode AD.Èad2A fast, simple, transposed Jacobian computed with Forward mode +) that combines the output with the input.ÉadCompute the Jacobian using Forward mode +%. This must transpose the result, so Ç( is faster and allows more result types.7jacobian (\[x,y] -> [y,x,x+y,x*y,exp x * sin y]) [pi,1]_[[0.0,1.0],[1.0,0.0],[1.0,1.0],[1.0,3.141592653589793],[19.472221418841606,12.502969588876512]]ÊadCompute the Jacobian using Forward mode +K and combine the output with the input. This must transpose the result, so È) is faster, and allows more result types.ËadCompute the Jacobian using Forward mode + along with the actual answer.ÌadCompute the Jacobian using Forward mode +W combined with the input using a user specified function, along with the actual answer.Íad9Compute the gradient of a function using forward mode AD.Note, this performs O(n) worse than () for n2 inputs, in exchange for better space utilization.ÎadDCompute the gradient and answer to a function using forward mode AD.Note, this performs O(n) worse than (* for n2 inputs, in exchange for better space utilization.ÏadCompute the gradient of a function using forward mode AD and combine the result with the input using a user-specified function.Note, this performs O(n) worse than (+ for n2 inputs, in exchange for better space utilization.ĞadCompute the gradient of a function using forward mode AD and the answer, and combine the result with the input using a user-specified function.Note, this performs O(n) worse than (, for n2 inputs, in exchange for better space utilization.gradWith' (,) sum [0..4]:(10.0,[(0.0,1.0),(1.0,1.0),(2.0,1.0),(3.0,1.0),(4.0,1.0)])+'¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏĞ+'ÍÎÏĞÉËÊÌÇÈÃÄÅÆ¿ÀÁÂ(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone =?@ACSX¡aÑadThe Ñh function calculates the gradient of a non-scalar-to-scalar function with kahn-mode AD in a single pass. grad (\[x,y,z] -> x*y+z) [1,2,3][2,1,1]ÒadThe Òs function calculates the result and gradient of a non-scalar-to-scalar function with kahn-mode AD in a single pass.+grad' (\[x,y,z] -> 4*x*exp y+cos z) [1,2,3]L(28.566231899122155,[29.5562243957226,29.5562243957226,-0.1411200080598672])ÓadÑ g fE function calculates the gradient of a non-scalar-to-scalar function fq with kahn-mode AD in a single pass. The gradient is combined element-wise with the argument using the function g. Ñ = Ó (_ dx -> dx) ˆ = Ó const ÔadÒ g fG calculates the result and gradient of a non-scalar-to-scalar function fp with kahn-mode AD in a single pass the gradient is combined element-wise with the argument using the function g. Ò == Ô (_ dx -> dx)ÕadThe Õ` function calculates the jacobian of a non-scalar-to-non-scalar function with kahn AD lazily in m passes for m outputs.$jacobian (\[x,y] -> [y,x,x*y]) [2,1][[0,1],[1,0],[1,2]],jacobian (\[x,y] -> [exp y,cos x,x+y]) [1,2]<[[0.0,7.38905609893065],[-0.8414709848078965,0.0],[1.0,1.0]]ÖadThe Öb function calculates both the result and the Jacobian of a nonscalar-to-nonscalar function, using m invocations of kahn AD, where m( is the output dimensionality. Applying fmap snd* to the result will recover the result of Õ | An alias for gradF'Kghci> jacobian' ([x,y] -> [y,x,x*y]) [2,1] [(1,[0,1]),(2,[1,0]),(2,[1,2])]×adR'jacobianWith g f' calculates the Jacobian of a non-scalar-to-non-scalar function f with kahn AD lazily in m passes for m outputs.kInstead of returning the Jacobian matrix, the elements of the matrix are combined with the input using the g. Õ = × (_ dx -> dx) × ‰ = (f x -> ‰ x Š f x) Øad×W g f' calculates both the result and the Jacobian of a nonscalar-to-nonscalar function f, using m invocations of kahn AD, where m( is the output dimensionality. Applying fmap snd* to the result will recover the result of ×kInstead of returning the Jacobian matrix, the elements of the matrix are combined with the input using the g. Ö == Ø (_ dx -> dx)Ùad%Compute the derivative of a function. diff sin 01.0cos 01.0ÚadThe ÚZ function calculates the value and derivative, as a pair, of a scalar-to-scalar function. diff' sin 0 (0.0,1.0)Ûad]Compute the derivatives of a function that returns a vector with regards to its single input.diffF (\a -> [sin a, cos a]) 0 [1.0,0.0]Üad{Compute the derivatives of a function that returns a vector with regards to its single input as well as the primal answer.diffF' (\a -> [sin a, cos a]) 0[(0.0,1.0),(1.0,0.0)]İad Compute the İ via the Õ* of the gradient. gradient is computed in ü mode and then the Õ is computed in ü mode.However, since the Ñ f :: f a -> f a9 is square this is not as fast as using the forward-mode Õ( of a reverse mode gradient provided by  #.hessian (\[x,y] -> x*y) [1,2] [[0,1],[1,0]]ŞadRCompute the order 3 Hessian tensor on a non-scalar-to-non-scalar function via the ü-mode Jacobian of the ü-mode Jacobian of the function.Less efficient than $%.;hessianF (\[x,y] -> [x*y,x+y,exp x*cos y]) [1,2 :: RDouble]r[[[0.0,1.0],[1.0,0.0]],[[0.0,0.0],[0.0,0.0]],[[-1.131204383757,-2.471726672005],[-2.471726672005,1.131204383757]]]øü  ÑÒÓÔÕÖ×ØÙÚÛÜİŞüÑÒÓÔÕÖ×ØİŞÙÚÛÜ  ø(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone =?@ACSXØßadThe ßh function calculates the gradient of a non-scalar-to-scalar function with kahn-mode AD in a single pass. grad (\[x,y,z] -> x*y+z) [1,2,3][2,1,1]grad (\[x,y] -> x**y) [0,2] [0.0,NaN]àadThe às function calculates the result and gradient of a non-scalar-to-scalar function with kahn-mode AD in a single pass.+grad' (\[x,y,z] -> 4*x*exp y+cos z) [1,2,3]L(28.566231899122155,[29.5562243957226,29.5562243957226,-0.1411200080598672])áadß g fE function calculates the gradient of a non-scalar-to-scalar function fq with kahn-mode AD in a single pass. The gradient is combined element-wise with the argument using the function g. ß = á (_ dx -> dx) ˆ = á const âadà g fG calculates the result and gradient of a non-scalar-to-scalar function fp with kahn-mode AD in a single pass the gradient is combined element-wise with the argument using the function g. à == â (_ dx -> dx)ãadThe ã` function calculates the jacobian of a non-scalar-to-non-scalar function with kahn AD lazily in m passes for m outputs.$jacobian (\[x,y] -> [y,x,x*y]) [2,1][[0,1],[1,0],[1,2]],jacobian (\[x,y] -> [exp y,cos x,x+y]) [1,2]<[[0.0,7.38905609893065],[-0.8414709848078965,0.0],[1.0,1.0]]äadThe äb function calculates both the result and the Jacobian of a nonscalar-to-nonscalar function, using m invocations of kahn AD, where m( is the output dimensionality. Applying fmap snd* to the result will recover the result of ã | An alias for gradF'Kghci> jacobian' ([x,y] -> [y,x,x*y]) [2,1] [(1,[0,1]),(2,[1,0]),(2,[1,2])]åadR'jacobianWith g f' calculates the Jacobian of a non-scalar-to-non-scalar function f with kahn AD lazily in m passes for m outputs.kInstead of returning the Jacobian matrix, the elements of the matrix are combined with the input using the g. ã = å (_ dx -> dx) å ‰ = (f x -> ‰ x Š f x) æadåW g f' calculates both the result and the Jacobian of a nonscalar-to-nonscalar function f, using m invocations of kahn AD, where m( is the output dimensionality. Applying fmap snd* to the result will recover the result of åkInstead of returning the Jacobian matrix, the elements of the matrix are combined with the input using the g. ä == æ (_ dx -> dx)çad%Compute the derivative of a function. diff sin 01.0cos 01.0èadThe èZ function calculates the value and derivative, as a pair, of a scalar-to-scalar function. diff' sin 0 (0.0,1.0)éad]Compute the derivatives of a function that returns a vector with regards to its single input.diffF (\a -> [sin a, cos a]) 0 [1.0,0.0]êad{Compute the derivatives of a function that returns a vector with regards to its single input as well as the primal answer.diffF' (\a -> [sin a, cos a]) 0[(0.0,1.0),(1.0,0.0)]ëad Compute the ë via the ã* of the gradient. gradient is computed in ü mode and then the ã is computed in ü mode.However, since the ß f :: f a -> f a9 is square this is not as fast as using the forward-mode ã( of a reverse mode gradient provided by  #.hessian (\[x,y] -> x*y) [1,2] [[0,1],[1,0]]ìadRCompute the order 3 Hessian tensor on a non-scalar-to-non-scalar function via the ü-mode Jacobian of the ü-mode Jacobian of the function.Less efficient than $%.;hessianF (\[x,y] -> [x*y,x+y,exp x*cos y]) [1,2 :: RDouble]r[[[0.0,1.0],[1.0,0.0]],[[0.0,0.0],[0.0,0.0]],[[-1.131204383757,-2.471726672005],[-2.471726672005,1.131204383757]]]+üßàáâãäåæçèéêëì+üßàáâãäåæëìçèéê(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone >HVX< íadThe íî function finds a zero of a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned. Examples: take 10 $ findZero (\x->x^2-4) 1I[1.0,2.5,2.05,2.000609756097561,2.0000000929222947,2.000000000000002,2.0].last $ take 10 $ findZero ((+1).(^2)) (1 :+ 1) 0.0 :+ 1.0îadThe î function behaves the same as í~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.ïadThe ïæ function inverts a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned.Example:)last $ take 10 $ inverse sqrt 1 (sqrt 10)10.0ğadThe ğ function behaves the same as ï~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.ñadThe ñŸ function find a fixedpoint of a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.)SIf the stream becomes constant ("it converges"), no further elements are returned.!last $ take 10 $ fixedPoint cos 10.7390851332151607òadThe ò function behaves the same as ñ~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.óadThe óî function finds an extremum of a scalar function using Newton's method; produces a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned.last $ take 10 $ extremum cos 10.0ôadThe ô function behaves the same as ó~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.õadThe õb function performs a multivariate optimization, based on the naive-gradient-descent in the file 1stalingrad/examples/flow-tests/pre-saddle-1a.vlad„ from the VLAD compiler Stalingrad sources. Its output is a stream of increasingly accurate results. (Modulo the usual caveats.)GIt uses reverse mode automatic differentiation to compute the gradient.öad`Perform a gradient descent using reverse mode automatic differentiation to compute the gradient. íîïğñòóôõö íîïğñòóôõö(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone&'456>HJSVX?¿÷adFConvex constraint, CC, is a GADT wrapper that hides the existential (sn) which is so prevalent in the rest of the API. This is an engineering convenience for managing the skolems.ùadThe ùî function finds a zero of a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned. Examples: take 10 $ findZero (\x->x^2-4) 1I[1.0,2.5,2.05,2.000609756097561,2.0000000929222947,2.000000000000002,2.0].last $ take 10 $ findZero ((+1).(^2)) (1 :+ 1) 0.0 :+ 1.0úadThe ú function behaves the same as ù~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.ûadThe ûæ function inverts a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned.Example:)last $ take 10 $ inverse sqrt 1 (sqrt 10)10.0üadThe ü function behaves the same as û~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.ıadThe ıŸ function find a fixedpoint of a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.)SIf the stream becomes constant ("it converges"), no further elements are returned.!last $ take 10 $ fixedPoint cos 10.7390851332151607şadThe ş function behaves the same as ı~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.ÿadThe ÿî function finds an extremum of a scalar function using Newton's method; produces a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned.last $ take 10 $ extremum cos 10.0adThe  function behaves the same as ÿ~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.adThe b function performs a multivariate optimization, based on the naive-gradient-descent in the file 1stalingrad/examples/flow-tests/pre-saddle-1a.vlad„ from the VLAD compiler Stalingrad sources. Its output is a stream of increasingly accurate results. (Modulo the usual caveats.)GIt uses reverse mode automatic differentiation to compute the gradient.adconstrainedDescent obj fs env optimizes the convex function obj$ subject to the convex constraints f <= 0 where f  fs˜. This is done using a log barrier to model constraints (i.e. Boyd, Chapter 11.3). The returned optimal point for the objective function must satisfy fs , but the initial environment, env, needn't be feasible.adLike + except the initial point must be feasible.adThe Ç function approximates the true gradient of the constFunction by a gradient at a single example. As the algorithm sweeps through the training set, it performs the update for each training example.†It uses reverse mode automatic differentiation to compute the gradient The learning rate is constant through out, and is set to 0.001ad`Perform a gradient descent using reverse mode automatic differentiation to compute the gradient.ad£Perform a conjugate gradient descent using reverse mode automatic differentiation to compute the gradient, and using forward-on-forward mode for computing extrema.let sq x = x * x7let rosenbrock [x,y] = sq (1 - x) + 100 * sq (y - sq x)rosenbrock [0,0]1Brosenbrock (conjugateGradientDescent rosenbrock [0, 0] !! 5) < 0.1TrueadiPerform a conjugate gradient ascent using reverse mode automatic differentiation to compute the gradient.÷øùúûüışÿùúûüışÿ÷ø(c) Edward Kmett 2015BSD3ekmett@gmail.com experimentalGHC onlyNone >HVX\² adThe  î function finds a zero of a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned. Examples: take 10 $ findZero (\x->x^2-4) 1I[1.0,2.5,2.05,2.000609756097561,2.0000000929222947,2.000000000000002,2.0] adThe   function behaves the same as  L except that it doesn't truncate the list once the results become constant. adThe  æ function inverts a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned.Example:)last $ take 10 $ inverse sqrt 1 (sqrt 10)10.0adThe  function behaves the same as  L except that it doesn't truncate the list once the results become constant.adThe Ÿ function find a fixedpoint of a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.)SIf the stream becomes constant ("it converges"), no further elements are returned.!last $ take 10 $ fixedPoint cos 10.7390851332151607adThe  function behaves the same as I except that doesn't truncate the list once the results become constant.adThe î function finds an extremum of a scalar function using Newton's method; produces a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned.last $ take 10 $ extremum cos 10.0adThe  function behaves the same as L except that it doesn't truncate the list once the results become constant.      (c) Edward Kmett 2015BSD3ekmett@gmail.com experimentalGHC onlyNone >HSVX€6 adThe î function finds a zero of a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned. Examples: take 10 $ findZero (\x->x^2-4) 1I[1.0,2.5,2.05,2.000609756097561,2.0000000929222947,2.000000000000002,2.0]adThe  function behaves the same as L except that it doesn't truncate the list once the results become constant.adThe æ function inverts a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned.Example:)last $ take 10 $ inverse sqrt 1 (sqrt 10)10.0adThe  function behaves the same as L except that it doesn't truncate the list once the results become constant.adThe Ÿ function find a fixedpoint of a scalar function using Newton's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.)SIf the stream becomes constant ("it converges"), no further elements are returned.!last $ take 10 $ fixedPoint cos 10.7390851332151607adThe  function behaves the same as I except that doesn't truncate the list once the results become constant.adThe î function finds an extremum of a scalar function using Newton's method; produces a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned.last $ take 10 $ extremum cos 10.0adThe  function behaves the same as L except that it doesn't truncate the list once the results become constant.ad£Perform a conjugate gradient descent using reverse mode automatic differentiation to compute the gradient, and using forward-on-forward mode for computing extrema.let sq x = x * x7let rosenbrock [x,y] = sq (1 - x) + 100 * sq (y - sq x)rosenbrock [0,0]1Brosenbrock (conjugateGradientDescent rosenbrock [0, 0] !! 5) < 0.1TrueadiPerform a conjugate gradient ascent using reverse mode automatic differentiation to compute the gradient.   (c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNoneÑ¡¥¶¸ !"#$%&'()*¥ ¡¶%¸!"#$&'()*(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNoneSX†×+adThe +j function calculates the gradient of a non-scalar-to-scalar function with sparse-mode AD in a single pass. grad (\[x,y,z] -> x*y+z) [1,2,3][2,1,1]grad (\[x,y] -> x**y) [0,2] [0.0,NaN]+¥+,-./012345678+¥+,3-./01245678(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNoneSX­9ad5Compute the answer and all derivatives of a function (a -> a):ad2Compute the zero-padded derivatives of a function (a -> a);ad5Compute the answer and all derivatives of a function  (a -> f a)<ad2Compute the zero-padded derivatives of a function  (a -> f a)=ad taylor f x compute the Taylor series of f around x.>ad taylor0 f x compute the Taylor series of f around x, zero-padded.?ad maclaurin f! compute the Maclaurin series of f@ad maclaurin f! compute the Maclaurin series of f , zero-paddedAad+Compute the first derivative of a function (a -> a)Bad6Compute the answer and first derivative of a function (a -> a)Cad/Compute a directional derivative of a function  (f a -> a)Dad>Compute the answer and a directional derivative of a function  (f a -> a)Ead/Compute a directional derivative of a function  (f a -> g a)Fad>Compute the answer and a directional derivative of a function  (f a -> g a)GadGiven a function  (f a -> a)P, and a tower of derivatives, compute the corresponding directional derivatives.HadGiven a function  (f a -> a)\, and a tower of derivatives, compute the corresponding directional derivatives, zero-paddedIadGiven a function  (f a -> g a)O, and a tower of derivatives, compute the corresponding directional derivativesJadGiven a function  (f a -> g a)\, and a tower of derivatives, compute the corresponding directional derivatives, zero-padded€9:;<=>?@ABCDEFGHIJ€=>?@AB9:;<CDGHEFIJ(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone¿KadThe Kî function finds a zero of a scalar function using Halley's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned. Examples: take 10 $ findZero (\x->x^2-4) 1B[1.0,1.8571428571428572,1.9997967892704736,1.9999999999994755,2.0].last $ take 10 $ findZero ((+1).(^2)) (1 :+ 1) 0.0 :+ 1.0LadThe L function behaves the same as K~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.MadThe Mæ function inverts a scalar function using Halley's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned. Note: the "take 10 $ inverse sqrt 1 (sqrt 10)j example that works for Newton's method fails with Halley's method because the preconditions do not hold!NadThe N function behaves the same as M~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.OadThe OŸ function find a fixedpoint of a scalar function using Halley's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.)SIf the stream becomes constant ("it converges"), no further elements are returned.!last $ take 10 $ fixedPoint cos 10.7390851332151607PadThe P function behaves the same as O~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.QadThe Qî function finds an extremum of a scalar function using Halley's method; produces a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned.take 10 $ extremum cos 1G[1.0,0.29616942658570555,4.59979519460002e-3,1.6220740159042513e-8,0.0]RadThe R function behaves the same as Q~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.KLMNOPQRKLMNOPQR(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNoneSXæSadThe Sî function finds a zero of a scalar function using Halley's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned. Examples: take 10 $ findZero (\x->x^2-4) 1B[1.0,1.8571428571428572,1.9997967892704736,1.9999999999994755,2.0].last $ take 10 $ findZero ((+1).(^2)) (1 :+ 1) 0.0 :+ 1.0TadThe T function behaves the same as S~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.UadThe Uæ function inverts a scalar function using Halley's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned. Note: the "take 10 $ inverse sqrt 1 (sqrt 10)j example that works for Newton's method fails with Halley's method because the preconditions do not hold!VadThe V function behaves the same as U~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.WadThe WŸ function find a fixedpoint of a scalar function using Halley's method; its output is a stream of increasingly accurate results. (Modulo the usual caveats.)SIf the stream becomes constant ("it converges"), no further elements are returned.!last $ take 10 $ fixedPoint cos 10.7390851332151607XadThe X function behaves the same as W~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.YadThe Yî function finds an extremum of a scalar function using Halley's method; produces a stream of increasingly accurate results. (Modulo the usual caveats.) If the stream becomes constant ("it converges"), no further elements are returned.take 10 $ extremum cos 1G[1.0,0.29616942658570555,4.59979519460002e-3,1.6220740159042513e-8,0.0]ZadThe Z function behaves the same as Y~ except that it doesn't truncate the list once the results become constant. This means it can be used with types without an  instance.STUVWXYZSTUVWXYZ(c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNoneSXè+€[\]^_`abcdefghijkl+€_`abcd[\]^efijghkl (c) Edward Kmett 2010-2015BSD3ekmett@gmail.com experimentalGHC onlyNone>HSVXmadm f wv% computes the product of the hessian H$ of a non-scalar-to-scalar function f at w = ‘  $ wv with a vector v = snd  $ wv# using "Pearlmutter's method" from  ?http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.29.6143, which states: %H v = (d/dr) grad_w (w + r v) | r = 0±Or in other words, we take the directional derivative of the gradient. The gradient is calculated in reverse mode, then the directional derivative is calculated in forward mode.nadn f wv6 computes both the gradient of a non-scalar-to-scalar f at w = ‘  $ wv and the product of the hessian H at w with a vector v = snd  $ wvT using "Pearlmutter's method". The outputs are returned wrapped in the same functor. %H v = (d/dr) grad_w (w + r v) | r = 0ÄOr in other words, we return the gradient and the directional derivative of the gradient. The gradient is calculated in reverse mode, then the directional derivative is calculated in forward mode.oad–Compute the Hessian via the Jacobian of the gradient. gradient is computed in reverse mode and then the Jacobian is computed in sparse (forward) mode.hessian (\[x,y] -> x*y) [1,2] [[0,1],[1,0]]padPCompute the order 3 Hessian tensor on a non-scalar-to-non-scalar function using 'Sparse'-on-'Reverse';hessianF (\[x,y] -> [x*y,x+y,exp x*cos y]) [1,2 :: RDouble]r[[[0.0,1.0],[1.0,0.0]],[[0.0,0.0],[0.0,0.0]],[[-1.131204383757,-2.471726672005],[-2.471726672005,1.131204383757]]]4 +¸ø  wxyz{|}~™š›œŸ ¡¢3468[\]^_`abijklmnop4+  wxyz3ø  ¸{|}~4¡¢o6p8mnŸ []\^™š›œijkl_`ab’-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXXYZ[\]^_`abcdefghijklmnopqrRUstuvwxyz{|}~€‚‚ƒ„…†‡ˆ‰Š‹Œ‘‘’“”•–—˜™š›œŸ ¡¢£¤¥¦§ ¨ ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Ì Í Î Î Ï Ğ Ñ Ò ² Ó ­ ® Ô Õ Ö × Ø Ù Ú Û Ü İ Ş ß à á â ã ä å æ ç è é ê ë ì í î ï ğ Í ñ ğ ò ò ó ô ô õ ö ÷ ø × ù ú û ü ı ş ÿ                     ÈÉÊËòÍñø÷×ûØÙÿ !"#$%&'()ê*+,-..×/0°²123456789:;<=>?@ABCDDñÍ/0°²×1234EFGHIJKLMNOPQRSTUñUÍÔVÒ²WXYZ[\]^_`abcde ) * + , f g h i j k l m # %nopqjklmrsfhgi)*+,tunopqjklmrsfhgi)*+,tunopqjklmrsfhgi)*+,nopqjklmrsfhgi)*+,)*+,fghijklm#%)*+,fghijklm#%vwxyz{|}~€€vwxyz{|}~‚ƒ„…†‡ˆvwxyz{|}vwxyz{|}„… ) * + , f g h i ‰ Š # ‹ % Œ)*+,fghi‰Š#‹%Œ‘’“”jknopq•–—˜vwxyz{|}vwxyz{|}‘’“”jknopq•–—˜ t u # %!™š›œ"Ÿ ¡Ÿ¢£"¤"¥Ÿ¦§"¨"© ªŸ « ¬ ­Ÿ®¯ ª ° ± ²Ÿ³´µ¶·²Ÿ®¸Ÿ®¹Ÿº»Ÿ®¼Ÿ½¾Ÿ½¿ÀÁŸ ÃÄŸÅÆÇad-4.3.6-9hhpqhswVuuHF4cpMfv5GpNumeric.AD.JetNumeric.AD.ModeNumeric.AD.JacobianNumeric.AD.Internal.TypeNumeric.AD.Internal.OrNumeric.AD.Internal.OnNumeric.AD.Internal.IdentityNumeric.AD.Rank1.TowerNumeric.AD.Internal.TowerNumeric.AD.Rank1.SparseNumeric.AD.Internal.SparseNumeric.AD.Mode.ReverseNumeric.AD.Internal.ReverseNumeric.AD.Rank1.KahnNumeric.AD.Internal.KahnNumeric.AD.Rank1.Forward.Double"Numeric.AD.Internal.Forward.DoubleNumeric.AD.Rank1.ForwardNumeric.AD.Internal.ForwardNumeric.AD.Internal.DenseNumeric.AD.Mode.ForwardNumeric.AD.Mode.Forward.DoubleNumeric.AD.Mode.KahnNumeric.AD.Rank1.NewtonNumeric.AD.NewtonNumeric.AD.Rank1.Newton.DoubleNumeric.AD.Newton.DoubleNumeric.AD.Mode.SparseNumeric.AD.Rank1.HalleyNumeric.AD.HalleyNumeric.AD.Mode.Tower Numeric.ADNumeric.AD.Internal.DoctestNumeric.AD.Internal.CombinatorshessianNumeric.AD.Mode.MixedhessianF Control.Arrow&&&Numeric.AD.Mode.Wengertgradgrad'gradWith gradWith'Jet:-tailJetheadJetjet$fTraversableJet $fFoldableJet $fFunctorJet $fShowJet$fShowShowableModeScalarisKnownConstant isKnownZeroauto*^^*^/zero $fModeRatio $fModeComplex $fModeWord64 $fModeWord32 $fModeWord16 $fModeWord8 $fModeWord $fModeNatural $fModeInt64 $fModeInt32 $fModeInt16 $fModeInt8 $fModeInteger $fModeInt $fModeFloat $fModeDoubleJacobianDunarylift1lift1_binarylift2lift2_ADrunAD$fModeAD$fEqAD$fOrdAD$fShowAD$fReadAD $fBoundedAD$fNumAD$fRealAD$fFractionalAD $fFloatingAD$fEnumAD $fRealFracAD $fRealFloatAD$fErfAD $fInvErfADOrLRChosenchooseTFrunLrunRchosen$fOrdOr$fEqOr$fModeOr $fRealFloatOr $fInvErfOr$fErfOr $fFloatingOr $fRealFracOr$fFractionalOr$fRealOr$fNumOr $fBoundedOr$fEnumOr $fChosenT $fChosenFOnoff$fModeOn$fEqOn$fEnumOn$fOrdOn $fBoundedOn$fNumOn$fRealOn$fFractionalOn $fRealFracOn $fFloatingOn$fErfOn $fInvErfOn $fRealFloatOnIdrunIdprobeunprobeprobedunprobed$fModeId$fEqId$fOrdId$fShowId$fEnumId $fBoundedId$fNumId$fRealId$fFractionalId $fFloatingId $fRealFracId $fRealFloatId $fSemigroupId $fMonoidId$fDataId$fErfId $fInvErfIdTowergetTowerzeroPadzeroPadF transposePadFdd'tangentsbundlewithDapply getADTowertower $fInvErfTower $fErfTower$fRealFracTower$fRealFloatTower $fRealTower $fEnumTower$fFloatingTower$fFractionalTower $fNumTower$fBoundedTower $fOrdTower $fEqTower$fJacobianTower $fModeTower $fShowTower $fDataTowerGradspacksunpacksGradpackunpackunpack'SparseZeroMonomial emptyMonomial addToMonomialindicesvarsskeletondspartialspartialprimalvgradvgrad'vgradsterms$fInvErfSparse $fErfSparse$fRealFracSparse$fRealFloatSparse $fRealSparse $fEnumSparse$fFloatingSparse$fFractionalSparse $fNumSparse$fBoundedSparse $fOrdSparse $fEqSparse$fJacobianSparse $fModeSparse $fGrad->->->a$fGradSparse[](,)a $fGrads->->a$fGradsSparseCofreea $fShowSparse $fDataSparseReverseLiftTapegetTapeHeadCellsNilUnaryBinary derivativeOf derivativeOf'partialspartialArrayOf partialMapOf reifyTapevarvarIdbindunbind unbindWith unbindMapunbindMapWithDefault$fInvErfReverse $fErfReverse$fRealFracReverse$fRealFloatReverse $fRealReverse $fEnumReverse$fFloatingReverse$fFractionalReverse $fNumReverse$fBoundedReverse $fOrdReverse $fEqReverse$fJacobianReverse $fModeReverse $fShowReverseKahnVar derivative derivative' partialArray partialMap $fInvErfKahn $fErfKahn$fRealFracKahn$fRealFloatKahn $fRealKahn $fEnumKahn$fFloatingKahn$fFractionalKahn $fNumKahn $fBoundedKahn $fOrdKahn$fEqKahn$fJacobianKahn $fModeKahn $fMuRefKahn$fGradKahn[](,)a $fShowTape $fDataTape $fShowKahn ForwardDoubletangentunbundlebind'bindWith bindWith' transposeWith$fInvErfForwardDouble$fErfForwardDouble$fRealFracForwardDouble$fRealFloatForwardDouble$fRealForwardDouble$fEnumForwardDouble$fFloatingForwardDouble$fFractionalForwardDouble$fNumForwardDouble$fOrdForwardDouble$fEqForwardDouble$fJacobianForwardDouble$fModeForwardDouble$fReadForwardDouble$fShowForwardDoubleForward$fInvErfForward $fErfForward$fRealFracForward$fRealFloatForward $fRealForward $fEnumForward$fFloatingForward$fFractionalForward $fNumForward$fBoundedForward $fOrdForward $fEqForward$fJacobianForward $fModeForward $fShowForward $fDataForwardDenseds' $fInvErfDense $fErfDense$fRealFracDense$fRealFloatDense $fRealDense $fEnumDense$fFloatingDense$fFractionalDense $fNumDense$fBoundedDense $fOrdDense $fEqDense$fJacobianDense $fModeDense $fShowDensejacobian jacobian' jacobianWith jacobianWith'diffdiff'diffFdiffF'dudu'duFduF' jacobianT jacobianWithThessianProducthessianProduct'findZero findZeroNoEqinverse inverseNoEq fixedPointfixedPointNoEqextremum extremumNoEqgradientDescentgradientAscentCCconstrainedDescentevalstochasticGradientDescentconjugateGradientDescentconjugateGradientAscent $fFunctorSEnv$fFoldableSEnv$fTraversableSEnvgrads jacobianshessian' hessianF'diffsdiffs0diffsFdiffs0Ftaylortaylor0 maclaurin maclaurin0dusdus0dusFdus0FRDoubleShowablefree-5.1-7nWoslxsTHwHbAsarxS9AaControl.Comonad.CofreeCofreezipWithTbase Data.FoldableFoldableData.Traversable TraversablezipWithDefaultT withPrimalGHC.EnumEnumfromBytakeWhileDifferent<+>sumpartialSmulGHC.Basemapunarilybinarily backPropagateGHC.ArrArraycontainers-0.6.0.1Data.IntMap.InternalIntMapidconst Data.Functor<$>Functor GHC.Floatsincosghc-prim GHC.ClassesEqelemconstrainedConvex' Data.Tuplefst