h&|r      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   (c) Justus Sagemller 2022GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred)*01  (c) Justus Sagemller 2022GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred)*/01< $linearmap-categoryBatteries-included version of ..)linearmap-categoryRead basis expansion from an array, starting at the specified offset. The array must have at least length  n + offset", else the behaviour is undefined.+linearmap-categoryThis class does not really pose any restrictions on a vector space type, but allows it to express its dimension. This is for optimisation purposes only, specifically to allow low-dimensional vectors to be represented efficiently in unboxed arrays / matrices.,linearmap-category If this is , it can mean the dimension is infinite, or just big, or simply unknown / not considered in the implementation..linearmap-categoryLow-level case distinction between spaces with a dimension that is both fixed and low enough that it makes sense to treat it this way, and more general spaces where this is not feasible..Use this type only when defining instances of +4. When making decisions based on dimensionality, $ is more convenient.4linearmap-categoryConvenience function. The result does never depend on the runtime input, only on its type.5linearmap-category?Read basis expansion from an array. The array must have length n%, else the behaviour is undefined.6linearmap-categoryRead basis expansion from an array, if the size equals the dimension.7linearmap-categoryWrite out basis expansion to an array, whose length will always be n.=linearmap-categoryTo be used as an @absurd@ values for implementing methods whose constraints combine to require both static- and flexible dimensionality (which can thus never be called).!The actual type of this should be 7 notStaticDimensionalContradiction :: D v n r . (n'&v, StaticDimension v ~ 'Nothing) => r GHC 9.6 baulks at that, though. It is a self-contradicting type, but that's the whole point...!"#$&%'*)(+-,.0/123456789:;<=.0/+-,'*)($&%#!"123456789:;<=(c) Justus Sagemller 2020GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred/1KK(c) Justus Sagemller 2016GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred: (c) Justus Sagemller 2016GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred/5Llinearmap-categoryA bilinear function is a linear function mapping to a linear function, or equivalently a 2-argument function that's linear in each argument independently. Note that this can not be uncurried to a linear function with a tuple argument (this would not be linear but quadratic).Mlinearmap-categoryInfix synonym of N., without explicit mention of the scalar type.Nlinearmap-categoryA linear map, represented simply as a Haskell function tagged with the type of scalar with respect to which it is linear. Many (sparse) linear mappings can actually be calculated much more efficiently if you don't represent them with any kind of matrix, but just as a function (which is after all, mathematically speaking, what a linear map foremostly is).However, if you sum up many N(s @ which you can simply do with the  instance @ they will become ever slower to calculate, because the summand-functions are actually computed individually and only the results summed. That's where   is generally preferrable. You can always convert between these equivalent categories using .linearmap-categoryelacs D S T.LMNPOQRSTUVV0 (c) Justus Sagemller 2016-2022GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred()*/125;<'Ylinearmap-categoryThe workhorse of this package: most functions here work on vector spaces that fulfill the Y v constraint.In summary, this is a  with an implementation for z v w, for any other space w , and with a c space. This fulfills c (c v) ~ v( (this constraint is encapsulated in w). To make a new space of yours an Y", you must define instances of y and b . In fact, Y is equivalent to b, but makes the condition explicit that the scalar and dual vectors also form a linear space. b# only stores that constraint in d$ (to avoid UndecidableSuperclasses).Zlinearmap-categoryInfix synonym for \., without explicit mention of the scalar type.[linearmap-categoryInfix synonym for _., without explicit mention of the scalar type.\linearmap-categoryTensor products are most interesting because they can be used to implement linear mappings, but they also form a useful vector space on their own right._linearmap-categoryThe tensor product between one space's dual space and another space is the space spanned by vector@dual-vector pairs, in  7https://en.wikipedia.org/wiki/Bra%E2%80%93ket_notationabra-ket notation written as  m = D |wOOv| Any linear mapping can be written as such a (possibly infinite) sum. The z data structure only stores the linear independent parts though; for simple finite-dimensional spaces this means e.g. _ B B B effectively boils down to an ordinary matrix type, namely an array of column-vectors |wO.(The Ov| dual-vectors are then simply assumed to come from the canonical basis.)For bigger spaces, the tensor product may be implemented in a more efficient sparse structure; this can be defined in the y instance.blinearmap-categoryThe class of vector spaces v for which _ s v w is well-implemented.clinearmap-category7Suitable representation of a linear map from the space v to its field.4For the usual euclidean spaces, you can just define c v = v. (In this case, a dual vector will be just a @row vector@ if you consider v-vectors as @column vectors@. _0 will then effectively have a matrix layout.)jlinearmap-categoryThis will probably be removed in the future, since infinite-dimensional (e.g. Banach-) spaces may be not isomorphic to their double dual.zlinearmap-category!The internal representation of a \ product.For Euclidean spaces, this is generally constructed by replacing each s scalar field in the v vector with an entire w7 vector. I.e., you have then a @nested vector@ or, if v is a  DualVector / @row vector@, a matrix.linearmap-category@Sanity-check@ a vector. This typically amounts to detecting any NaN components, which should trigger a Nothing) result. Otherwise, the result should be Just the input, but may also be optimised / memoised if applicable (i.e. for function spaces).linearmap-categoryA coercion that is compatible with the vector space structure of the types. Intended to be used for lossless conversion between newtype wrappers around vector spaces, under the requirement that they internally use the same basis (if any). Note that this does not mean they also need to have the same inner product / dual space.linearmap-categoryInfix version of .linearmap-categoryThe dual operation to the tuple constructor, or rather to the  fanout operation: evaluate two (linear) functions in parallel and sum up the results. The typical use is to concatenate @row vectors@ in a matrix definition.linearmap-categoryASCII version of linearmap-category@((v'Ew)+>x) -> ((v+>w)+>x)linearmap-category ((v+>w)+>x) -> ((v'Ew)+>x)linearmap-category (u+>(vEw)) -> (u+>v)Ewlinearmap-category (u+>v)Ew -> u+>(vEw)linearmap-category ((u+>v)+>w) -> uE(v+>w)linearmap-category (uE(v+>w)) -> (u+>v)+>wlinearmap-category ((uEv)+>w) -> (u+>(v+>w))linearmap-category (u+>(v+>w)) -> ((uEv)+>w)linearmap-categoryUse a function as a linear map. This is only well-defined if the function is+ linear (this condition is not checked).WXYZ[\^]_a`bvutsrqpnmlojihgfedkcwxy~}|{zZ707666(c) Justus Sagemller 2020GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred )*1)M(c) Justus Sagemller 2022GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred) (c) Justus Sagemller 2016-2019GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred/125*7(c) Justus Sagemller 2016GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred)*/125<ATlinearmap-categoryWhereas 4-values refer to a single basis vector, a single  value represents a collection of such basis vectors, which can be used to associate a vector with a list of coefficients.*For spaces with a canonical finite basis,  does not actually need to contain any information, it can simply have the full finite basis as its only value. Even for large sparse spaces, it should only have a very coarse structure that can be shared by many vectors.linearmap-categorySplit up a linear map in @column vectors@ WRT some suitable basis.linearmap-categoryExpand in the given basis, if possible. Else yield a superbasis of the given one, in which this is) possible, and the decomposition therein.linearmap-categoryAssemble a vector from coefficients in some basis. Return any excess coefficients.linearmap-categoryGiven a function that interprets a coefficient-container as a vector representation, build a linear function mapping to that space.linearmap-categoryThe existance of a finite basis gives us an isomorphism between a space and its dual space. Note that this isomorphism is not natural (i.e. it depends on the actual choice of basis, unlike everything else in this library).linearmap-category is the class of vector spaces with finite subspaces in which you can define a basis that can be used to project from the whole space into the subspace. The usual application is for using a kind of  -https://en.wikipedia.org/wiki/Galerkin_methodGalerkin method) to give an approximate solution (see ) to a linear equation in a possibly infinite-dimensional space.Of course, this also works for spaces which are already finite-dimensional themselves.linearmap-categoryLazily enumerate choices of a basis of functionals that can be made dual to the given vectors, in order of preference (which roughly means, large in the normal direction.) I.e., if the vector ) is assigned early to the dual vector ', then (' $ ) should be large and all the other products comparably small.The purpose is that we should be able to make this basis orthonormal with a ~Gaussian-elimination approach, in a way that stays numerically stable. This is otherwise known as the choice of a pivot element.For simple finite-dimensional array-vectors, you can easily define this method using .linearmap-category=Inverse function application, aka solving of a linear system: f  f  v D v f  f  u D u If f does not have full rank, the behaviour is undefined. However, it does not need to be a proper isomorphism: the first of the above equations is still fulfilled if only f is  injective2 (overdetermined system) and the second if it is  surjective.If you want to solve for multiple RHS vectors, be sure to partially apply this operator to the linear map, like map (f ) [vA, vA, ...] Since most of the work is actually done in triangularising the operator, this may be much faster than [f  vA, f  vA, ...] linearmap-categoryIf f is injective, then unsafeLeftInverse f . f D id linearmap-categoryIf f is surjective, then  f . unsafeRightInverse f D id linearmap-categoryInvert an isomorphism. For other linear maps, the result is undefined.linearmap-categoryThe  :https://en.wikipedia.org/wiki/Riesz_representation_theoremRiesz representation theorem provides an isomorphism between a Hilbert space and its (continuous) dual space.linearmap-categoryFunctions are generally a pain to display, but since linear functionals in a Hilbert space can be represented by vectors7 in that space, this can be used for implementing a  instance.linearmap-categoryOuter product of a general v!-vector and a basis element from w. Note that this operation is in general pretty inefficient; it is provided mostly to lay out matrix definitions neatly.linearmap-categoryThis is the preferred method for showing linear maps, resulting in a matrix view involving the ) operator. We don't provide a generic  instance; to make linear maps with your own finite-dimensional type V (with scalar S+) showable, this is the recommended way:  instance RieszDecomposable V where rieszDecomposition = ... instance (FiniteDimensional w, w ~ DualVector w, Scalar w ~ S, Show w) => Show (LinearMap S w V) where showsPrec = rieszDecomposeShowsPrec /Note that the custom type should always be the codomain7 type, whereas the domain should be kept parametric.linearmap-category&For real matrices, this boils down to . For free complex spaces it also incurs complex conjugation.'The signature can also be understood as 6adjoint :: (v +> w) -> (DualVector w +> DualVector v) Or 6adjoint :: (DualVector v +> DualVector w) -> (w +> v) But not (v+>w) -> (w+>v), in general (though in a Hilbert space, this too is equivalent, via  isomorphism).linearmap-category#Set of canonical basis functionals.linearmap-categoryDecompose a vector in absolute value components. the list indices should correspond to those in the functional list.linearmap-categorySuitable definition of .4077(c) Justus Sagemller 2016GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred/C;linearmap-category4Generalised multiplication operation. This subsumes  and  . For scalars therefore also  , and for , .7(c) Justus Sagemller 2021GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred )*125;?J,linearmap-categoryDo not manually instantiate this class. It is used internally by .linearmap-category Given a type V that is already a  and , generate the other class instances that are needed to use the type with this library.Prerequisites: (these can often be derived automatically, using either the newtype / via! strategy or generics / anyclass)  instance  V instance < V where type Scalar V = -- a simple number type, usually  instance 8 V where type Basis V = -- a type with an instance of  Note that the  does not need to be orthonormal @ in fact it is not necessary to have a scalar product (i.e. an  instance) at all.The macro, invoked like % makeLinearSpaceFromBasis [t| V |] will then generate V-instances for the classes  ,  , , y and b.It also works on parameterised types, in that case you need to use universal-quantification syntax, e.g. :makeLinearSpaceFromBasis [t| D n . (KnownNat n) => V n |] linearmap-categoryMore general version of /, that can be used with parameterised types.linearmap-categoryLike -, but additionally generate instances for  and .linearmap-categoryMore powerful version of deriving newtype:, specialised to the classes from this package (and of manifolds-core). The c space will be a separate type, even if the type you abstract over is self-dual.  bckdefghijolmnpqrstuvyz{|}~  yz{|}~bckdefghijolmnpqrstuv (c) Justus Sagemller 2016GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred()*/5<K777(c) Justus Sagemller 2016GPL v3(@) jsag $ hvl.no experimentalportable Safe-Inferred/5n'linearmap-categoryHow well the data uncertainties match the deviations from the model's synthetic data.   = 1   D y  y  Where  is the number of degrees of freedom (data values minus model parameters),  y = m x - yd is the deviation from given data to the data the model would predict (for each sample point), and y is the a-priori measurement uncertainty of the data points. Values >1 indicate that the data could not be described satisfyingly; D1 suggests overfitting or that the data uncertainties have been postulated too high. 1http://adsabs.harvard.edu/abs/1997ieas.book.....TIf the model is exactly determined or even underdetermined (i.e. D0 ) then  is undefined.linearmap-categoryThe model that best corresponds to the data, in a least-squares sense WRT the supplied norm on the data points. In other words, this is the model that minimises  D y / y.linearmap-categoryThe estimated eigenvalue .linearmap-categoryNormalised vector v( that gets mapped to a multiple, namely:linearmap-categoryf $ v D  *^ v .linearmap-category Deviation of v to (f$v)^/). Ideally, this would of course be equal.linearmap-categorySquared norm of the deviation.linearmap-categoryA space in which you can use  both for scaling with a real number, and as dot-product for obtaining such a number.linearmap-category&A multidimensional variance of points v with some distribution can be considered a norm on the dual space, quantifying for a dual vector dv the expectation value of (dv .^v)^2.linearmap-category1A @norm@ that may explicitly be degenerate, with  m|$|v T 0 for some  v D zeroV.linearmap-categoryA positive (semi)definite symmetric bilinear form. This gives rise to a  0https://en.wikipedia.org/wiki/Norm_(mathematics)norm thus:   n  v = D(n v  v) Strictly speaking, this type is neither strong enough nor general enough to deserve the name : it includes proper s (i.e.  m|$|v D 0 does not guarantee  v == zeroV), but not actual norms such as the BA-norm on B@ (Taxcab norm) or the supremum norm. However, A-like norms are the only ones that can really be formulated without any basis reference; and guaranteeing positive definiteness through the type system is scarcely practical.linearmap-category8A linear map that simply projects from a dual vector in u to a vector in v. (du  v) u D v  (du  u) linearmap-categoryA seminorm defined by @v@ = D(D: Od:|vO) for some dual vectors d:. If given a complete basis of the dual space, this generates a proper .If the d:0 are a complete orthonormal system, you get the  (in an inefficient form).linearmap-categoryModify a norm in such a way that the given vectors lie within its unit ball. (Not  optimally/ @ the unit ball may be bigger than necessary.)linearmap-categoryScale the result of a norm with the absolute of the given number. &scaleNorm  n |$| v = abs  * (n|$|v) Equivalently, this scales the norm's unit ball by the reciprocal of that factor.linearmap-categoryThe canonical standard norm (2-norm) on inner-product / Hilbert spaces.linearmap-categoryThe norm induced from the (arbitrary) choice of basis in a finite space. Only use this in contexts where you merely need some norm, but don't care if it might be biased in some unnatural way.linearmap-categoryA proper norm induces a norm on the dual space @ the @reciprocal norm@. (The orthonormal systems of the norm and its dual are mutually conjugate.) The dual norm of a seminorm is undefined.linearmap-category in the opposite direction. This is actually self-inverse; with d/ you can replace each with the other direction.linearmap-categoryThe unique positive number whose norm is 1 (if the norm is not constant zero).linearmap-categoryUnsafe version of , only works reliable if the norm is actually positive definite.linearmap-category@Partially apply@ a norm, yielding a dual vector (i.e. a linear form that accepts the second argument of the scalar product). (  v)  w D v  w  See also .linearmap-category&The squared norm. More efficient than / because that needs to take the square root.linearmap-categoryUse a * to measure the length / norm of a vector.  |$| v D D(v  v) linearmap-categoryFlipped, @ket@ version of . v  (w |&> ) D v  w linearmap-category /  are inefficient if the number of vectors is similar to the dimension of the space, or even larger than it. Use this function to optimise the underlying operator to a dense matrix representation.linearmap-categoryLike , but also perform a @sanity check@ to eliminate NaN etc. problems.linearmap-categoryLazily compute the eigenbasis of a linear map. The algorithm is essentially a hybrid of Lanczos/Arnoldi style Krylov-spanning and QR-diagonalisation, which we don't do separately but  interleave at each step.The size of the eigen-subbasis increases with each step until the space's dimension is reached. (But the algorithm can also be used for infinite-dimensional spaces.)linearmap-categoryFind a system of vectors that approximate the eigensytem, in the sense that: each true eigenvalue is represented by an approximate one, and that is closer to the true value than all the other approximate EVs.This function does not make any guarantees as to how well a single eigenvalue is approximated, though.linearmap-categorySimple automatic finding of the eigenvalues and -vectors of a Hermitian operator, in reasonable approximation.9This works by spanning a QR-stabilised Krylov basis with  until it is complete (3), and then properly decoupling the system with 7 (based on two iterations of shifted Givens rotations).=This function is a tradeoff in performance vs. accuracy. Use  and  directly for more quickly computing a (perhaps incomplete) approximation, or for more precise results.linearmap-category!Approximation of the determinant.linearmap-category Inverse of . Equivalent to  on the dual space.linearmap-categoryFor any two norms, one can find a system of co-vectors that, with suitable coefficients, spans either of them: if &shSys = sharedNormSpanningSystem nA nA , then nA =  $ fst $shSys and nA =  [dv^* | (dv,)<-shSys] A rather crude approximation () is used in this function, so do not expect the above equations to hold with great accuracy.linearmap-category2Like 'sharedNormSpanningSystem nA nA', but allows either of the norms to be singular. nA =  [dv | (dv, Just _)<-shSys] and nA =  $ [dv^* | (dv, Just )<-shSys] ++ [ dv | (dv, Nothing)<-shSys] You may also interpret a Nothing here as an @infinite eigenvalue@, i.e. it is so small as an spanning vector of nA> that you would need to scale it by D to use it for spanning nA.linearmap-categoryA system of vectors which are orthogonal with respect to both of the given seminorms. (In general they are not  orthonormal to either of them.)linearmap-categoryInterpret a variance as a covariance between two subspaces, and normalise it by the variance on u. The result is effectively the linear regression coefficient of a simple regression of the vectors spanning the variance.linearmap-categorySimple wrapper of .linearmap-category $(m<>n|$|v)^2 T (m|$|v)^2 + (n|$|v)^2linearmap-category mempty|$|v D 0linearmap-categoryThe notion of orthonormality.linearmap-category+Error bound for deviations from eigen-ness.linearmap-categoryOperator to calculate the eigensystem of. Must be Hermitian WRT the scalar product defined by the given metric.linearmap-category(Starting vector(s) for the power method.linearmap-categoryInfinite sequence of ever more accurate approximations to the eigensystem of the operator.  !"#'()*+,-LMNOPQRSTUVWXYZ[\]^_`abckdefghijolmnpqrstuvcwxyz{|}~zNOPMLV_`a[\]^ZY+,-'()*!"#yz{|}~bckdefghijolmnpqrstuvQTUSRXWwx76001 !"#$%$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab c d e e f g h i j k l m n o p q r r s   t u v w x y z { | } ~                                                 p                                                                         1linearmap-category-0.6.0.1-ILwttX6sg75L4hJ3MHoGtK*Math.LinearMap.Category.Instances.Deriving Math.VectorSpace.ZeroDimensional1Math.VectorSpace.DimensionAware.Theorems.MaybeNatMath.VectorSpace.DimensionAware*Math.VectorSpace.MiscUtil.MultiConstraintsMath.LinearMap.CategoryMath.LinearMap.CoercionMath.VectorSpace.Dual#Math.LinearMap.Category.DerivativesMath.LinearMap.Asserted LinearMapMath.LinearMap.Category.Class!Math.LinearMap.Category.InstancesMath.VectorSpace.Docile"Math.LinearMap.Category.TensorQuot1data-default-class-0.1.2.0-CQYBH38PFES4dDyailJWvdData.Default.Classdef(vector-space-0.16-KoCdcguQFxx2Nf7k8frJMlData.AffineSpace AffineSpaceDiff.-..+^-manifolds-core-0.6.1.0-KuNCXrWMCuy7Hkv7Og2egoMath.Manifold.Core.PseudoAffinesemimanifoldWitness.-~^.+~^Needle SemimanifoldpseudoAffineWitness.-~!.-~. PseudoAffine)Math.Manifold.VectorSpace.ZeroDimensionalOriginZeroDimFmapTriangularNum TriangularNum BindMaybePred MaybePred ZipWithTimes ZipWithPlusZipWith justNatSingsuccMaybePredSing maybePredSingbinMaybePredSingtriangularNumSingfmapTriangularNumSingzipWithPlusSingzipWithTimesSingzipWithTimesAssoczipWithTimesCommuStaticDimensionaldimensionIsStatic DimensionDimensionalityCasesStaticDimensionalCaseFlexibleDimensionalCase DimensionalknownDimensionalitySingunsafeFromArrayWithOffsetunsafeWriteArrayWithOffsetDimensionAwareStaticDimensiondimensionalityWitnessDimensionalityWitnessIsStaticDimensionalIsFlexibleDimensionaldimensionalitySingdimensionality dimension dimensionOfunsafeFromArray fromArraytoArraystaticDimensionSingscalarUnsafeFromArrayWithOffset scalarUnsafeWriteArrayWithOffset unsafeFromArrayWithOffsetViaList!unsafeWriteArrayWithOffsetViaList!notStaticDimensionalContradiction$fDimensionalnm(,)$fDimensional1Ratio$fDimensional1Integer$fDimensional1Int$fDimensional1Double$fDimensional1Float$fDimensionAware(,)$fDimensionAwareRatio$fDimensionAwareInteger$fDimensionAwareInt$fDimensionAwareDouble$fDimensionAwareFloat$fStaticDimensionalv SameScalarBilinear-+>LinearFunctiongetLinearFunctionaddVbilinearFunction flipBilinscaleinner-+$> Fractional' DualSpaceLSpace⊗+>TensorgetTensorProduct getLinearMap LinearSpace DualVectordualSpaceWitnesslinearIdidTensorsampleLinearFunction toLinearFormfromLinearFormcoerceDoubleDualtracecontractTensorMapcontractMapTensorcontractTensorFncontractLinearMapAgainstapplyDualVector applyLinear composeLineartensorIdapplyTensorFunctionalapplyTensorLinMapuseTupleLinearSpaceComponentsDualSpaceWitness TensorSpace TensorProductscalarSpaceWitnesslinearManifoldWitness zeroTensor toFlatTensorfromFlatTensor addTensorssubtractTensors scaleTensor negateTensor tensorProducttensorProductstransposeTensor fmapTensorfzipTensorWithtensorUnsafeFromArrayWithOffset tensorUnsafeWriteArrayWithOffsetcoerceFmapTensorProductwellDefinedVectorwellDefinedTensor VSCCoercionLinearManifoldWitnessScalarSpaceWitnessNum'closedScalarWitnesstrivialTensorWitnessTrivialTensorWitnessClosedScalarWitness-+$=>asTensor fromTensor asLinearMap fromLinearMap⊕>+<lfun ValidDualnessSpacedualityWitnessdecideDualnessDualnessSingletons VectorWitnessFunctionalWitnessDualityWitnessDualDualnessVector FunctionalusingAnyDualness$fValidDualnessFunctional$fValidDualnessVector⊗〃+>SymmetricTensor SymTensorgetSymmetricTensor<.>^squareVsquareVs currySymBilin SimpleSpace RealFloat' RealFrac' HilbertSpaceTensorDecomposabletensorDecompositiontensorDecompose'showsPrecBasisRieszDecomposablerieszDecompositionFiniteDimensionalSubBasis entireBasisenumerateSubBasissubbasisDimensiondecomposeLinMapdecomposeLinMapWithin recomposeSBrecomposeSBTensorrecomposeLinMaprecomposeContraLinMaprecomposeContraLinMapTensoruncanonicallyFromDualuncanonicallyToDualtensorEqualitydualFinitenessWitnessDualFinitenessWitness SemiInnerdualBasisCandidatestensorDualBasisCandidatessymTensorDualBasisCandidates"symTensorTensorDualBasisCandidatescartesianDualBasisCandidatesembedFreeSubspace\$ pseudoInverserieszsRieszcoRieszshowsPrecAsRiesz.<rieszDecomposeShowsPrec.⊗tensorDecomposeShowsPrecadjoint·BasisGeneratedSpaceproveTensorProductIsTrie$LinearSpaceFromBasisDerivationConfigAbstractDualVectormakeLinearSpaceFromBasismakeFiniteDimensionalFromBasiscopyNewtypeInstances-$fDefaultLinearSpaceFromBasisDerivationConfig3$fDefaultFiniteDimensionalFromBasisDerivationConfig!$fPseudoAffineDualVectorFromBasis $fAffineSpaceDualVectorFromBasis!$fSemimanifoldDualVectorFromBasis $fTensorSpaceDualVectorFromBasis!$fDimensionalnDualVectorFromBasis#$fDimensionAwareDualVectorFromBasis$fKnownCardinality(,)$fKnownCardinalityEither$fKnownCardinality()$fKnownCardinalityVoid$f#nm(,) $f#nmEither$f#1()$f#0Void$fSemiInnerDualVectorFromBasis&$fFiniteDimensionalDualVectorFromBasis $fLinearSpaceDualVectorFromBasis$fShowAbstractDualVector$fSemiInnerAbstractDualVector%$fFiniteDimensionalAbstractDualVector$fLinearSpaceAbstractDualVector$fTensorSpaceAbstractDualVector $fDimensionalnAbstractDualVector"$fDimensionAwareAbstractDualVector$fVectorSpaceAbstractDualVector $fPseudoAffineAbstractDualVector $fSemimanifoldAbstractDualVector$fAffineSpaceAbstractDualVector!$fAdditiveGroupAbstractDualVector$fEqDualVectorFromBasis"$fAdditiveGroupDualVectorFromBasis $fVectorSpaceDualVectorFromBasis$fHasBasisDualVectorFromBasis$fEqAbstractDualVector/∂*∂.∂LinearRegressionResultlinearFit_χν²linearFit_bestModellinearFit_modelUncertaintyLinearShowable Eigenvector ev_Eigenvalueev_Eigenvectorev_FunctionApplied ev_Deviation ev_Badness RealSpaceVarianceSeminormNorm applyNorm-+|>spanNorm spanVariance relaxNorm scaleNorm euclideanNormdualNorm dualNorm' transformNormtransformVariancefindNormalLength normalLength<$|normSq|$||&> densifyNormwellDefinedNormconstructEigenSystemfinishEigenSystemroughEigenSystemeigenroughDetnormSpanningSystemnormSpanningSystem'varianceSpanningSystemsharedNormSpanningSystemsharedSeminormSpanningSystemsharedSeminormSpanningSystem' dependencesummandSpaceNormssumSubspaceNormsconvexPolytopeHullsymmetricPolytopeOuterVerticeslinearRegressionWlinearRegression $fShowNorm$fSemigroupNorm $fMonoidNorm$fShowEigenvectorbase GHC.MaybeNothingData.VectorSpace VectorSpace5constrained-categories-0.4.2.0-AszvNTAgKr0EHCjxag888cControl.Arrow.ConstrainedarrelacslinearFunction scaleWithscaleVconst0lNegateV fmapScalelCoFstlCoSndbiConst0lApply&&& argFromTensor argAsTensordeferLinearMaphasteLinearMapcoCurryLinearMapcoUncurryLinearMapcurryLinearMapuncurryLinearMapGenericNeedle'getGenericNeedle'GenericTupleDualgetVSCCoercionsymVSCfirstVSC secondVSCunsafeFollowVSCunsafeFloutVSC fmapLinearMappseudoFmapTensorLHSpseudoPrecomposeLinmapenvTensorLHSCoercionenvLinmapPrecomposeCoercion<⊕ lfstBlock lsndBlocktensorDimensionAssoc lassocTensor rassocTensoruncurryLinearFnsampleLinearFunctionFn fromLinearFn asLinearFnexposeLinearFngenericTensorspaceErrorusingNonTupleTypeAsTupleErrorLinearApplicativeSpacegetLinearApplicativeSpaceℝautoLinearManifoldWitness&tensorUnsafeFromArrayWithOffsetViaList'tensorUnsafeWriteArrayWithOffsetViaList Data.BasisBasis$unsafeLeftInverseunsafeRightInverse unsafeInverseGHC.ShowShow Data.OldList transpose ZeroBasis LinMapBasis SymTensBasis TensorBasis TupleBasisV4BasisV3BasisV2BasisV1Basis RealsBasisV0BasisDListorthonormaliseDuals dualBasis dualBasis' zipTravWith⊗<$>^/^recomposeMultipletensTensorEquality tensorLinmapDecompositionhelperslmTensorEquality^ multiSplit*^GHC.Num* InnerSpace<.> TensorQuot⨸HasBasisData.AdditiveGroup AdditiveGroupghc-prim GHC.TypesDouble&MemoTrie-0.6.10-4WDFPAWcMmrHQPbtzJ2p3j Data.MemoTrieHasTriemakeLinearSpaceFromBasis'^* adhocNormzeroV^+^^-^negateVScalarproject normalized magnitude magnitudeSq linearCombolerp^/inSum2inSumsumVSumgetSum^%