Music.Theory.Diagram.Path

Functions to make path diagrams such as those in Fig. VIII-11 on I.Xenakis Formalized Music.

Genera

parts :: [a] -> [([a], a, [a])]

Set of all (pre,element,post) triples of a sequence.

 parts "abc" == [("",'a',"bc"),("a",'b',"c"),("ab",'c',"")]

parts' :: [a] -> [(a, [a])]

All (element,remainder) pairs for a sequence.

 parts' "abc" == [('a',"bc"),('b',"ac"),('c',"ab")]

gather :: Ord a => [(a, i)] -> [(a, [i])]

Gather elements with equal keys.

 gather (zip "abcba" [0..]) == [('a',[0,4]),('b',[1,3]),('c',[2])]

Geometry

ln_on :: Ln R -> Ln R -> Bool

Does either endpoint of the lhs Ln lie on the rhs Ln.

 ln_on (ln' (1/2,1/2) (1/2,1)) (ln' (0,0) (1,1)) == True
 ln_on (ln' (1/2,0) (1/2,1)) (ln' (0,0) (1,1)) == False

overlap :: Ln R -> Ln R -> Bool

Do Lns overlap in the particular sense of being ln_parallel and at least one endpoint of one line lying on the other.

includes :: Ln R -> Ln R -> Bool

Do both points of the rhs Ln lie on the lhs Ln.

is_included :: Ln R -> Ln R -> Bool

flip includes.

pt_fn :: ((a, a) -> b) -> Pt a -> b

Apply f to x and y duple of Pt.

ln_fn :: (Num a, Eq a) => ((Pt a, Pt a) -> b) -> Ln a -> b

Apply f to start and end Pt duple of Ln.

ln_pt_fn :: (Num a, Eq a, Num b, Eq b) => (Pt a -> Pt b) -> Ln a -> Ln b

Apply f to start and end Pts of Ln and construct Ln.

to_unit :: R -> [Ln R] -> [Ln R]

Scale set of Ln to lie in area given by (0,n).

Orientation

data Orientation a

Enumeration of Vertical, Horizontal and Diagonal.

Constructors

Vertical

Horizontal

Diagonal a

Instances

Eq a => Eq (Orientation a)

Show a => Show (Orientation a)

orientation :: (Fractional a, Eq a) => Ln a -> Orientation a

Calculate Orientation of Ln.

 orientation (ln' (0,0) (0,1)) == Vertical
 orientation (ln' (0,0) (1,0)) == Horizontal
 orientation (ln' (0,0) (1,1)) == Diagonal 1

Shift Map

type Shift_Map a = [(Pt a, [Orientation a])]

A table Pt and Orientation set pairs.

mk_shift_map :: [Ln R] -> Shift_Map R

Construct a Shift_Map from a set of Lns.

shift_map_pt :: Shift_Map R -> Pt R -> Pt R

Apply Shift_Map to a Pt.

shift_map_ln :: Shift_Map R -> Ln R -> Ln R

Apply Shift_Map to a Ln.

Shift table

type Shift_Table a = [(Pt a, Pt a)]

A table of Pt pairs.

mk_shift_tbl_m :: (Ln R, Bool) -> Maybe (Shift_Table R)

Make element of Shift_Table.

mk_shift_tbl :: Collision_Table -> Shift_Table R

Make complete Shift_Table.

shift_table_ln :: Shift_Table R -> Ln R -> Ln R

Apply Shift_Table to Ln.

Collision table

type Collision_Table = [(Ln R, Bool)]

Table of Lns indicating collisions.

mk_collision_table :: [Ln R] -> Collision_Table

Construct Collision_Table for a set of Ln.

collision_table_rewrite :: Collision_Table -> [Ln R]

Construct Shift_Table from Collision_Table and shift all Ln.

Path diagram

type Path_Diagram = [(Int, Int)]

A diagram given as a set of Int pairs.

path_diagram_ln :: Path_Diagram -> [Ln R]

Construct set of Ln from Path_Diagram.

mk_path_ct :: Path_Diagram -> [Ln R]

Collision_Table based resolution of Path_Diagram.

mk_path_sm :: Path_Diagram -> [Ln R]

Shift_Map variant of mk_path_ct.