Name: numeric-prelude Version: 0.4.0.1 x-revision: 1 License: GPL License-File: LICENSE Author: Dylan Thurston , Henning Thielemann , Mikael Johansson Maintainer: Henning Thielemann Homepage: http://www.haskell.org/haskellwiki/Numeric_Prelude Category: Math Stability: Experimental Tested-With: GHC==6.4.1, GHC==6.8.2, GHC==6.10.4, GHC==6.12.3 Tested-With: GHC==7.2.2, GHC==7.4.1, GHC==7.6.3 Cabal-Version: >=1.6 Build-Type: Simple Synopsis: An experimental alternative hierarchy of numeric type classes Description: Revisiting the Numeric Classes . The Prelude for Haskell 98 offers a well-considered set of numeric classes which covers the standard numeric types ('Integer', 'Int', 'Rational', 'Float', 'Double', 'Complex') quite well. But they offer limited extensibility and have a few other flaws. In this proposal we will revisit these classes, addressing the following concerns: . [1] The current Prelude defines no semantics for the fundamental operations. For instance, presumably addition should be associative (or come as close as feasible), but this is not mentioned anywhere. . [2] There are some superfluous superclasses. For instance, 'Eq' and 'Show' are superclasses of 'Num'. Consider the data type @ data IntegerFunction a = IF (a -> Integer) @ One can reasonably define all the methods of 'Algebra.Ring.C' for @IntegerFunction a@ (satisfying good semantics), but it is impossible to define non-bottom instances of 'Eq' and 'Show'. In general, superclass relationship should indicate some semantic connection between the two classes. . [3] In a few cases, there is a mix of semantic operations and representation-specific operations. 'toInteger', 'toRational', and the various operations in 'RealFloating' ('decodeFloat', ...) are the main examples. . [4] In some cases, the hierarchy is not finely-grained enough: Operations that are often defined independently are lumped together. For instance, in a financial application one might want a type \"Dollar\", or in a graphics application one might want a type \"Vector\". It is reasonable to add two Vectors or Dollars, but not, in general, reasonable to multiply them. But the programmer is currently forced to define a method for '(*)' when she defines a method for '(+)'. . In specifying the semantics of type classes, I will state laws as follows: . > (a + b) + c === a + (b + c) . The intended meaning is extensional equality: The rest of the program should behave in the same way if one side is replaced with the other. Unfortunately, the laws are frequently violated by standard instances; the law above, for instance, fails for 'Float': . > (1e20 + (-1e20)) + 1.0 = 1.0 > 1e20 + ((-1e20) + 1.0) = 0.0 . For inexact number types like floating point types, thus these laws should be interpreted as guidelines rather than absolute rules. In particular, the compiler is not allowed to use them for optimization. Unless stated otherwise, default definitions should also be taken as laws. . Thanks to Brian Boutel, Joe English, William Lee Irwin II, Marcin Kowalczyk, Ketil Malde, Tom Schrijvers, Ken Shan, and Henning Thielemann for helpful comments. . . Usage: . Write modules in the following style: . > [-# NoImplicitPrelude #-] > module MyModule where > > ... various specific imports ... > > import NumericPrelude . Importing @NumericPrelude@ is almost the same as . > import NumericPrelude.Numeric > import NumericPrelude.Base . . Instead of the @NoImplicitPrelude@ pragma you could also write @import Prelude ()@ but this will yield problems with numeric literals. . There are two wrapper types that allow types to be used with both Haskell98 and NumericPrelude type classes that are initially implemented for only one of them. . . Scope & Limitations\/TODO: . * It might be desireable to split Ord up into Poset and Ord (a total ordering). This is not addressed here. . * In some cases, this hierarchy may not yet be fine-grained enough. For instance, time spans (\"5 minutes\") can be added to times (\"12:34\"), but two times are not addable. (\"12:34 + 8:23\") As it stands, users have to use a different operator for adding time spans to times than for adding two time spans. Similar issues arise for vector space et al. This is a consciously-made tradeoff, but might be changed. This becomes most serious when dealing with quantities with units like @length\/distance^2@, for which @(*)@ as defined here is useless. (One way to see the issue: should @ f x y = iterate (x *) y @ have principal type @ (Ring.C a) => a -> a -> [a] @ or something like @ (Ring.C a, Module a b) => a -> b -> [b] @ ?) . * I stuck with the Haskell 98 names. In some cases I find them lacking. Neglecting backwards compatibility, we have renamed classes as follows: Num --> Additive, Ring, Absolute Integral --> ToInteger, IntegralDomain, RealIntegral Fractional --> Field Floating --> Algebraic, Transcendental Real --> ToRational RealFrac --> RealRing, RealField RealFloat --> RealTranscendental . . Additional standard libraries might include Enum, IEEEFloat (including the bulk of the functions in Haskell 98's RealFloat class), VectorSpace, Ratio, and Lattice. Extra-Source-Files: Makefile docs/NOTES docs/README src/Algebra/GenerateRules.hs Flag splitBase description: Choose the new smaller, split-up base package. Flag buildTests description: Build test executables default: False Source-Repository this Tag: 0.4.0.1 Type: darcs Location: http://code.haskell.org/numeric-prelude/ Source-Repository head Type: darcs Location: http://code.haskell.org/numeric-prelude/ Library Build-Depends: parsec >=1 && <4, QuickCheck >=1 && <3, storable-record >=0.0.1 && <0.1, non-negative >=0.0.5 && <0.2, utility-ht >=0.0.6 && <0.1, deepseq >=1.1 && <1.4 If flag(splitBase) Build-Depends: base >= 4.5 && <5, array >=0.1 && <0.5, containers >=0.1 && <0.6, random >=1.0 && <1.1 Else Build-Depends: base >= 1.0 && < 2 If impl(ghc>=7.0) CPP-Options: -DNoImplicitPrelude=RebindableSyntax Extensions: CPP GHC-Options: -Wall Hs-source-dirs: src Exposed-modules: Algebra.Absolute Algebra.Additive Algebra.Algebraic Algebra.Differential Algebra.DimensionTerm Algebra.DivisibleSpace Algebra.Field Algebra.FloatingPoint Algebra.Indexable Algebra.IntegralDomain Algebra.NonNegative Algebra.Lattice Algebra.Laws Algebra.Module Algebra.ModuleBasis Algebra.Monoid Algebra.NormedSpace.Euclidean Algebra.NormedSpace.Maximum Algebra.NormedSpace.Sum Algebra.OccasionallyScalar Algebra.PrincipalIdealDomain Algebra.RealField Algebra.RealIntegral Algebra.RealRing Algebra.RealTranscendental Algebra.RightModule Algebra.Ring Algebra.ToInteger Algebra.ToRational Algebra.Transcendental Algebra.Units Algebra.Vector Algebra.VectorSpace Algebra.ZeroTestable MathObj.Algebra MathObj.DiscreteMap MathObj.LaurentPolynomial MathObj.Matrix MathObj.Monoid MathObj.PartialFraction MathObj.Permutation MathObj.Permutation.CycleList MathObj.Permutation.CycleList.Check MathObj.Permutation.Table MathObj.Polynomial MathObj.Polynomial.Core MathObj.PowerSeries MathObj.PowerSeries.Core MathObj.PowerSeries.DifferentialEquation MathObj.PowerSeries.Example MathObj.PowerSeries.Mean MathObj.PowerSeries2 MathObj.PowerSeries2.Core MathObj.PowerSum MathObj.RefinementMask2 MathObj.RootSet MathObj.Wrapper.Haskell98 MathObj.Wrapper.NumericPrelude Number.Complex Number.DimensionTerm Number.DimensionTerm.SI Number.FixedPoint Number.FixedPoint.Check Number.GaloisField2p32m5 Number.NonNegative Number.NonNegativeChunky Number.PartiallyTranscendental Number.Peano Number.Positional Number.Positional.Check Number.Quaternion Number.Ratio Number.ResidueClass Number.ResidueClass.Check Number.ResidueClass.Maybe Number.ResidueClass.Func Number.ResidueClass.Reader Number.Root Number.OccasionallyScalarExpression Number.SI.Unit Number.SI Number.Physical.Unit Number.Physical.UnitDatabase Number.Physical Number.Physical.Read Number.Physical.Show NumericPrelude.List.Checked NumericPrelude.List.Generic NumericPrelude.Elementwise NumericPrelude.Numeric NumericPrelude.Base NumericPrelude Other-modules: NumericPrelude.List Algebra.AffineSpace Algebra.RealRing98 MathObj.Gaussian.Variance MathObj.Gaussian.Bell MathObj.Gaussian.Polynomial Number.ComplexSquareRoot -- I think I won't add them this way. -- It is certainly better to split the class into comparison and selection. Algebra.EqualityDecision Algebra.OrderDecision Executable test Hs-Source-Dirs: src, test GHC-Options: -Wall Main-Is: Test.hs If !flag(buildTests) Buildable: False If impl(ghc>=7.0) CPP-Options: -DNoImplicitPrelude=RebindableSyntax Extensions: CPP Executable testsuite Hs-Source-Dirs: src, test GHC-Options: -Wall Other-modules: Test.NumericPrelude.Utility Test.Number.GaloisField2p32m5 Test.Number.ComplexSquareRoot Test.Algebra.IntegralDomain Test.Algebra.RealRing Test.Algebra.Additive Test.MathObj.RefinementMask2 Test.MathObj.PartialFraction Test.MathObj.Matrix Test.MathObj.Polynomial Test.MathObj.PowerSeries Test.MathObj.Gaussian.Variance Test.MathObj.Gaussian.Bell Test.MathObj.Gaussian.Polynomial Main-Is: Test/Run.hs If flag(buildTests) Build-Depends: HUnit >=1 && <2 Else Buildable: False If impl(ghc>=7.0) CPP-Options: -DNoImplicitPrelude=RebindableSyntax Extensions: CPP Executable test-gaussian Hs-Source-Dirs: src, test Main-Is: Gaussian.hs Other-Modules: MathObj.Gaussian.Example If flag(buildTests) Build-Depends: gnuplot >=0.5 && <0.6, HTam >=0.0.2 && <0.1 Else Buildable: False If impl(ghc>=7.0) CPP-Options: -DNoImplicitPrelude=RebindableSyntax Extensions: CPP