Construct set of n - 1 adjacent indices, left right order.

adjacent_indices 5 == [(0,1),(1,2),(2,3),(3,4)]

All (i,j) indices, in half matrix order.

all_indices 4 == [(0,1),(0,2),(0,3),(1,2),(1,3),(2,3)]

A list notation for matrices.

Apply f to construct Matrix from sequence.

matrix_f (,) [1..3] == [[(1,1),(1,2),(1,3)]
                       ,[(2,1),(2,2),(2,3)]
                       ,[(3,1),(3,2),(3,3)]]

Construct matrix_f with compare (p.263).

contour_matrix [1..3] == [[EQ,LT,LT],[GT,EQ,LT],[GT,GT,EQ]]

Half matrix notation for contour.

Half Matrix of contour given comparison function f.

half_matrix_f (flip (-)) [2,10,6,7] == [[8,4,5],[-4,-3],[1]]
half_matrix_f (flip (-)) [5,0,3,2] == [[-5,-2,-3],[3,2],[-1]]
half_matrix_f compare [5,0,3,2] == [[GT,GT,GT],[LT,LT],[GT]]

Construct Contour_Half_Matrix (p.264)

Show function for Contour_Half_Matrix.

Description notation of contour.

Construct Contour_Description of contour (p.264).

let c = [[3,2,4,1],[3,2,1,4]]
in map (show.contour_description) c == ["202 02 2","220 20 0"]

Show function for Contour_Description (p.264).

Convert from Contour_Half_Matrix notation to Contour_Description.

Ordering from ith to jth element of sequence described at d.

contour_description_ix (contour_description "abdc") (0,3) == LT

True if contour is all descending, equal or ascending.

let c = ["abc","bbb","cba"]
in map (uniform.contour_description) c == [True,True,True]

True if contour does not containt any EQ elements.

let c = ["abc","bbb","cba"]
map (no_equalities.contour_description) c == [True,False,True]

Set of all contour descriptions.

map (length.all_contours) [3,4,5] == [27,729,59049]

A sequence of orderings (i,j) and (j,k) may imply ordering for (i,k).

map implication [(LT,EQ),(EQ,EQ),(EQ,GT)] == [Just LT,Just EQ,Just GT]

List of all violations at a Contour_Description (p.266).

Is the number of violations zero.

All possible contour descriptions

map (length.possible_contours) [3,4,5] == [13,75,541]

All impossible contour descriptions

map (length.impossible_contours) [3,4,5] == [14,654,58508]

Calculate number of contours of indicated degree (p.263).

map contour_description_lm [2..7] == [1,3,6,10,15,21]

let r = [3,27,729,59049,14348907]
in map (\n -> 3 ^ n) (map contour_description_lm [2..6]) == r

Truncate a Contour_Description to have at most n elements.

let c = contour_description [3,2,4,1]
in contour_truncate c 3 == contour_description [3,2,4]

Is Contour_Description p a prefix of q.

let {c = contour_description [3,2,4,1]
    ;d = contour_description [3,2,4]}
in d `contour_is_prefix_of` c == True

Are Contour_Descriptions p and q equal at column n.

let {c = contour_description [3,2,4,1,5]
    ;d = contour_description [3,2,4,1]}
in map (contour_eq_at c d) [0..4] == [True,True,True,True,False]

Derive an Integral contour that would be described by Contour_Description. Diverges for impossible contours.

draw_contour (contour_description "abdc") == [0,1,3,2]

Invert Contour_Description.

let c = contour_description "abdc"
in draw_contour (contour_description_invert c) == [3,2,0,1]

Function to perhaps generate an element and a new state from an initial state. This is the function provided to unfoldr.

Function to test is a partial sequence conforms to the target sequence.

Transform a Build_f to produce at most n elements.

let f i = Just (i,succ i)
in unfoldr (build_f_n f) (5,'a') == "abcde"

Attempt to construct a sequence of n elements given a Build_f to generate possible elements, a Conforms_f that the result sequence must conform to at each step, an Int to specify the maximum number of elements to generate when searching for a solution, and an initial state.

let {b_f i = Just (i,i+1)
    ;c_f i x = odd (sum x `div` i)}
in build_sequence 6 b_f c_f 20 0 == (Just [1,2,6,11,15,19],20)

Attempt to construct a sequence that has a specified contour. The arguments are a Build_f to generate possible elements, a Contour_Description that the result sequence must conform to, an Int to specify the maximum number of elements to generate when searching for a solution, and an initial state.

import System.Random

let {f = Just . randomR ('a','z')
    ;c = contour_description "atdez"
    ;st = mkStdGen 2347}
in fst (build_contour f c 1024 st) == Just "nvruy"

A variant on build_contour that retries a specified number of times using the final state of the failed attempt as the state for the next try.

let {f = Just . randomR ('a','z')
    ;c = contour_description "atdezjh"
    ;st = mkStdGen 2347}
in fst (build_contour_retry f c 64 8 st) == Just "nystzvu"

A variant on build_contour_retry that returns the set of all sequences constructed.

let {f = Just . randomR ('a','z')
    ;c = contour_description "atdezjh"
    ;st = mkStdGen 2347}
in length (build_contour_set f c 64 64 st) == 60

Variant of build_contour_set that halts when an generated sequence is a duplicate of an already generated sequence.

let {f = randomR ('a','f')
    ;c = contour_description "cafe"
    ;st = mkStdGen 2346836
    ;r = build_contour_set_nodup f c 64 64 st}
in filter ("c" `isPrefixOf`) r == ["cafe","cbed","caed"]

Example from p.262 (quarter-note durations)

ex_1 == [2,3/2,1/2,1,2]
compare_adjacent ex_1 == [GT,GT,LT,LT]
show (contour_half_matrix ex_1) == "2221 220 00 0"
draw_contour (contour_description ex_1) == [3,2,0,1,3]

let d = contour_description_invert (contour_description ex_1)
in (show d,is_possible d) == ("0001 002 22 2",True)

Example on p.265 (pitch)

ex_2 == [0,5,3]
show (contour_description ex_2) == "00 2"

Example on p.265 (pitch)

ex_3 == [12,7,6,7,8,7]
show (contour_description ex_3) == "22222 2101 000 01 2"
contour_description_ix (contour_description ex_3) (0,5) == GT
is_possible (contour_description ex_3) == True

Example on p.266 (impossible)

show ex_4 == "2221 220 00 1"
is_possible ex_4 == False
violations ex_4 == [(0,3,4,GT),(1,3,4,GT)]