cartesian -package:comfort-array

The Cartesian coordinate system. Coordinates are (x,y,z).

LPFP-core LPFPCore LPFPCore.CoordinateSystems

class (Category k, Monoid (UnitObject k), Object k (UnitObject k)) => Cartesian k

constrained-categories Control.Category.Constrained Control.Category.Constrained.Prelude

Quite a few categories (monoidal categories) will permit "products" of objects as objects again – in the Haskell sense those are tuples – allowing for "dyadic morphisms" (x,y) ~> r. Together with a unique UnitObject, this makes for a monoidal structure, with a few natural isomorphisms. Ordinary tuples may not always be powerful enough to express the product objects; we avoid making a dedicated associated type for the sake of simplicity, but allow for an extra constraint to be imposed on objects prior to consideration of pair-building. The name Cartesian is disputable: in category theory that would rather Imply cartesian closed category (which we represent with Curry). Monoidal would make sense, but we reserve that to Functors.

package Cartesian

Uses

Not on Stackage, so not searched. Coordinate systems

module Control.Category.Cartesian

monoidal-functors

class (Semicartesian cat t, Tensor cat t i) => Cartesian cat t i | i -> t, t -> i

monoidal-functors Control.Category.Cartesian

A Category equipped with a Tensor t where the Tensor unit i is the terminal object in cat and thus every object a is equipped with a morphism <math>, which we call kill.

Laws

fwd unitl . glmap kill . split ≡ id
fwd unitr . grmap kill . split ≡ id

cartesianProduct :: Set a -> Set b -> Set (a, b)

containers Data.Set Data.Set.Internal

Calculate the Cartesian product of two sets.

cartesianProduct xs ys = fromList $ liftA2 (,) (toList xs) (toList ys)

Example:

cartesianProduct (fromList [1,2]) (fromList ['a','b']) =
fromList [(1,'a'), (1,'b'), (2,'a'), (2,'b')]

cartesianProductWith :: Ord c => (a -> b -> c) -> Set a -> Set b -> Set c

algebraic-graphs Algebra.Graph.Internal

Compute the Cartesian product of two sets, applying a function to each resulting pair.

cartesianProduct :: (a -> b -> c) -> [a] -> [b] -> [c]

universe-base Data.Universe.Helpers

Slightly unfair 2-way Cartesian product: given two (possibly infinite) lists, produce a single list such that whenever v and w have finite indices in the input lists, (v,w) has finite index in the output list. Lower indices occur as the fst part of the tuple more frequently, but not exponentially so.

cartesianProduct :: NESet a -> NESet b -> NESet (a, b)

nonempty-containers Data.Set.NonEmpty

Calculate the Cartesian product of two sets.

cartesianProduct xs ys = fromList $ liftA2 (,) (toList xs) (toList ys)

Example:

cartesianProduct (fromList (1:|[2])) (fromList ('a':|['b'])) =
fromList ((1,'a') :| [(1,'b'), (2,'a'), (2,'b')])

cartesianFromSquare :: T (Square sh) -> T (sh, sh)

comfort-blas Numeric.BLAS.Slice

cartesianCoordinates :: Position -> (Double, Double, Double)

learn-physics Physics.Learn Physics.Learn.Position

Returns the three Cartesian coordinates as a triple from a position.

cartesianCoordinates :: Position -> (R, R, R)

LPFP-core LPFPCore LPFPCore.CoordinateSystems

cartesianProduct :: forall s t a b . (KnownSet s a, KnownSet t b) => SomeSetWith (ProductProof 'Regular s t) (a, b)

refined-containers Data.Set.Refined

Cartesian product of two sets. The elements are all pairs (x, y) for each x from s and for each y from t.

class (Morphism k, HasAgent k) => CartesianAgent k

constrained-categories Control.Arrow.Constrained

CartesianAttachUnit :: (Object k α, UnitObject k ~ u, ObjectPair k α u) => ReCartesian k α (α, u)

constrained-categories Control.Category.Constrained.Reified

CartesianCompo :: Object k β => ReCartesian k α β -> ReCartesian k β γ -> ReCartesian k α γ

constrained-categories Control.Category.Constrained.Reified

CartesianDetachUnit :: (Object k α, UnitObject k ~ u, ObjectPair k α u) => ReCartesian k (α, u) α

constrained-categories Control.Category.Constrained.Reified

CartesianId :: Object k α => ReCartesian k α α

constrained-categories Control.Category.Constrained.Reified

CartesianRegroup :: (ObjectPair k α β, ObjectPair k β γ, ObjectPair k α (β, γ), ObjectPair k (α, β) γ) => ReCartesian k (α, (β, γ)) ((α, β), γ)

constrained-categories Control.Category.Constrained.Reified

CartesianRegroup_ :: (ObjectPair k α β, ObjectPair k β γ, ObjectPair k α (β, γ), ObjectPair k (α, β) γ) => ReCartesian k ((α, β), γ) (α, (β, γ))

constrained-categories Control.Category.Constrained.Reified

CartesianSwap :: (ObjectPair k α β, ObjectPair k β α) => ReCartesian k (α, β) (β, α)

constrained-categories Control.Category.Constrained.Reified

unfairCartesianProduct :: (a -> b -> c) -> [a] -> [b] -> [c]

universe-base Data.Universe.Helpers

Very unfair 2-way Cartesian product: same guarantee as the slightly unfair one, except that lower indices may occur as the fst part of the tuple exponentially more frequently.

class (Category k, Object k (ZeroObject k)) => CoCartesian k

constrained-categories Control.Category.Constrained

Monoidal categories need not be based on a cartesian product. The relevant alternative is coproducts. The dual notion to Cartesian replaces such products (pairs) with sums (Either), and unit () with void types. Basically, the only thing that doesn't mirror Cartesian here is that we don't require CoMonoid (ZeroObject k). Comonoids do in principle make sense, but not from a Haskell viewpoint (every type is trivially a comonoid). Haskell of course uses sum types, variants, most often without Either appearing. But variants are generally isomorphic to sums; the most important (sums of unit) are methods here.