Music.Theory.Array.Cell_Ref

Cell references & indexing.

Documentation

data Column_Ref

A indexed case-insensitive column references. The column following Z is AA.

Constructors

Column_Ref

Fields

• column_ref_string :: String

Instances

Enum Column_Ref

Methods

succ :: Column_Ref -> Column_Ref

pred :: Column_Ref -> Column_Ref

toEnum :: Int -> Column_Ref

fromEnum :: Column_Ref -> Int

enumFrom :: Column_Ref -> [Column_Ref]

enumFromThen :: Column_Ref -> Column_Ref -> [Column_Ref]

enumFromTo :: Column_Ref -> Column_Ref -> [Column_Ref]

enumFromThenTo :: Column_Ref -> Column_Ref -> Column_Ref -> [Column_Ref]

Eq Column_Ref

Methods

(==) :: Column_Ref -> Column_Ref -> Bool

(/=) :: Column_Ref -> Column_Ref -> Bool

Ord Column_Ref

Methods

compare :: Column_Ref -> Column_Ref -> Ordering

(<) :: Column_Ref -> Column_Ref -> Bool

(<=) :: Column_Ref -> Column_Ref -> Bool

(>) :: Column_Ref -> Column_Ref -> Bool

(>=) :: Column_Ref -> Column_Ref -> Bool

max :: Column_Ref -> Column_Ref -> Column_Ref

min :: Column_Ref -> Column_Ref -> Column_Ref

Read Column_Ref

Methods

readsPrec :: Int -> ReadS Column_Ref

readList :: ReadS [Column_Ref]

readPrec :: ReadPrec Column_Ref

readListPrec :: ReadPrec [Column_Ref]

Show Column_Ref

Methods

showsPrec :: Int -> Column_Ref -> ShowS

show :: Column_Ref -> String

showList :: [Column_Ref] -> ShowS

Ix Column_Ref

Methods

range :: (Column_Ref, Column_Ref) -> [Column_Ref]

index :: (Column_Ref, Column_Ref) -> Column_Ref -> Int

unsafeIndex :: (Column_Ref, Column_Ref) -> Column_Ref -> Int

inRange :: (Column_Ref, Column_Ref) -> Column_Ref -> Bool

rangeSize :: (Column_Ref, Column_Ref) -> Int

unsafeRangeSize :: (Column_Ref, Column_Ref) -> Int

IsString Column_Ref

Methods

fromString :: String -> Column_Ref

type Column_Range = (Column_Ref, Column_Ref)

Inclusive range of column references.

type Row_Ref = Int

1-indexed row reference.

row_index :: Row_Ref -> Int

Zero index of Row_Ref.

type Row_Range = (Row_Ref, Row_Ref)

Inclusive range of row references.

type Cell_Ref = (Column_Ref, Row_Ref)

Cell reference, column then row.

type Cell_Range = (Cell_Ref, Cell_Ref)

Inclusive range of cell references.

letter_index :: Char -> Int

Case folding letter to index function. Only valid for ASCII letters.

map letter_index ['A' .. 'Z'] == [0 .. 25]
map letter_index ['a','d' .. 'm'] == [0,3 .. 12]

index_letter :: Int -> Char

Inverse of letter_index.

map index_letter [0,3 .. 12] == ['A','D' .. 'M']

column_index :: Column_Ref -> Int

Translate column reference to 0-index.

:set -XOverloadedStrings
map column_index ["A","c","z","ac","XYZ"] == [0,2,25,28,17575]

interior_column_index :: Column_Range -> Column_Ref -> Int

Column reference to interior index within specified range. Type specialised index.

map (Data.Ix.index ('A','Z')) ['A','C','Z'] == [0,2,25]
map (interior_column_index ("A","Z")) ["A","C","Z"] == [0,2,25]

map (Data.Ix.index ('B','C')) ['B','C'] == [0,1]
map (interior_column_index ("B","C")) ["B","C"] == [0,1]

column_ref :: Int -> Column_Ref

Inverse of column_index.

let c = ["A","Z","AA","AZ","BA","BZ","CA"]
in map column_ref [0,25,26,51,52,77,78] == c

column_ref (0+25+1+25+1+25+1) == "CA"

column_ref_pred :: Column_Ref -> Column_Ref

Type specialised pred.

column_ref_pred "DF" == "DE"

column_ref_succ :: Column_Ref -> Column_Ref

Type specialised succ.

column_ref_succ "DE" == "DF"

column_indices :: Column_Range -> (Int, Int)

Bimap of column_index.

column_indices ("b","p") == (1,15)
column_indices ("B","IT") == (1,253)

column_range :: Column_Range -> [Column_Ref]

Type specialised range.

column_range ("L","R") == ["L","M","N","O","P","Q","R"]
Data.Ix.range ('L','R') == "LMNOPQR"

column_in_range :: Column_Range -> Column_Ref -> Bool

Type specialised inRange.

map (column_in_range ("L","R")) ["A","N","Z"] == [False,True,False]
map (column_in_range ("L","R")) ["L","N","R"] == [True,True,True]

map (Data.Ix.inRange ('L','R')) ['A','N','Z'] == [False,True,False]
map (Data.Ix.inRange ('L','R')) ['L','N','R'] == [True,True,True]

column_range_size :: Column_Range -> Int

Type specialised rangeSize.

map column_range_size [("A","Z"),("AA","ZZ")] == [26,26 * 26]
Data.Ix.rangeSize ('A','Z') == 26

row_range :: Row_Range -> [Row_Ref]

Type specialised range.

cell_ref_minima :: Cell_Ref

The standard uppermost leftmost cell reference, A1.

Just cell_ref_minima == parse_cell_ref "A1"

parse_cell_ref :: String -> Maybe Cell_Ref

Cell reference parser for standard notation of (column,row).

parse_cell_ref "CC348" == Just ("CC",348)

is_cell_ref :: String -> Bool

parse_cell_ref_err :: String -> Cell_Ref

cell_ref_pp :: Cell_Ref -> String

Cell reference pretty printer.

cell_ref_pp ("CC",348) == "CC348"

cell_index :: Cell_Ref -> (Int, Int)

Translate cell reference to 0-indexed pair.

cell_index ("CC",348) == (80,347)
Data.Ix.index (("AA",1),("ZZ",999)) ("CC",348) == 54293

index_to_cell :: (Int, Int) -> Cell_Ref

Inverse of cell_index.

index_to_cell (80,347) == (Column_Ref "CC",348)
index_to_cell (4,5) == (Column_Ref "E",6)

parse_cell_index :: String -> (Int, Int)

cell_range :: Cell_Range -> [Cell_Ref]

Type specialised range, cells are in column-order.

cell_range (("AA",1),("AC",1)) == [("AA",1),("AB",1),("AC",1)]

let r = [("AA",1),("AA",2),("AB",1),("AB",2),("AC",1),("AC",2)]
in cell_range (("AA",1),("AC",2)) == r

Data.Ix.range (('A',1),('C',1)) == [('A',1),('B',1),('C',1)]

let r = [('A',1),('A',2),('B',1),('B',2),('C',1),('C',2)]
in Data.Ix.range (('A',1),('C',2)) == r

cell_range_row_order :: Cell_Range -> [Cell_Ref]

Variant of cell_range in row-order.

let r = [(AA,1),(AB,1),(AC,1),(AA,2),(AB,2),(AC,2)]
in cell_range_row_order (("AA",1),("AC",2)) == r