Data.Tensort.Utils.Types

This module provides types used in the Tensort package

Since these packages are only for sorting Ints currently, every data type is a structure of Ints

Documentation

data TensortProps

TensortProps contains the Bytesize and SubAlgorithm used in a Tensort algorithm

Constructors

TensortProps

Fields

• bytesize :: Int
• subAlgorithm :: SortAlg

type Bit = Int

A Bit is a single element of the list to be sorted. For our current purposes that means it is an Int

type BitR = Record

This is a Bit type that is used when sorting Records in a recursive Tensort variant

data SBit

This is a conversion type that allows for sorting both Bits and Records. It is useful in recursive Tensort variants

Constructors

SBitBit Bit

SBitRec Record

Instances

Show SBit

Defined in Data.Tensort.Utils.Types

Methods

showsPrec :: Int -> SBit -> ShowS

show :: SBit -> String

showList :: [SBit] -> ShowS

Eq SBit

Defined in Data.Tensort.Utils.Types

Methods

(==) :: SBit -> SBit -> Bool

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

Ord SBit

Defined in Data.Tensort.Utils.Types

Methods

compare :: SBit -> SBit -> Ordering

(<) :: SBit -> SBit -> Bool

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

(>) :: SBit -> SBit -> Bool

(>=) :: SBit -> SBit -> Bool

max :: SBit -> SBit -> SBit

min :: SBit -> SBit -> SBit

fromSBitBit :: SBit -> Bit

Converts an SBit to a Bit

fromSBitRec :: SBit -> Record

Converts an SBit to a Record

type Byte = [Bit]

A Byte is a list of Bits standardized to a fixed maximum length (Bytesize)

The length should be set either in or upstream of any function that uses Bytes

type ByteR = [Record]

This is a Byte type that is used when sorting Records in a recursive Tensort variant

type Address = Int

An Address is a index number pointing to data stored in Memory

type TopBit = Bit

A TopBit contains a copy of the last (i.e. highest) Bit in a Byte or Tensor

type TopBitR = Record

This is a TopBit type that is used when sorting Records in a recursive Tensort variant

type Record = (Address, TopBit)

A Record is an element in a Tensor's Register containing an Address pointer and a TopBit value

A Record's Address is an index number pointing to a Byte or Tensor in the Tensor's Memory

A Record's TopBit is a copy of the last (i.e. highest) Bit in the Byte or Tensor that the Record references

type RecordR = (Address, TopBitR)

This is a Record type that is used when sorting Records in a recursive Tensort variant

data SRecord

This is a conversion type that allows for sorting both Records and Bits. It is useful in recursive Tensort variants

Constructors

SRecordBit Record

SRecordRec RecordR

Instances

Show SRecord

Defined in Data.Tensort.Utils.Types

Methods

showsPrec :: Int -> SRecord -> ShowS

show :: SRecord -> String

showList :: [SRecord] -> ShowS

Eq SRecord

Defined in Data.Tensort.Utils.Types

Methods

(==) :: SRecord -> SRecord -> Bool

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

Ord SRecord

Defined in Data.Tensort.Utils.Types

Methods

compare :: SRecord -> SRecord -> Ordering

(<) :: SRecord -> SRecord -> Bool

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

(>) :: SRecord -> SRecord -> Bool

(>=) :: SRecord -> SRecord -> Bool

max :: SRecord -> SRecord -> SRecord

min :: SRecord -> SRecord -> SRecord

fromSRecordBit :: SRecord -> Record

Converts an SRecord to a Record

fromSRecordRec :: SRecord -> RecordR

Converts an SRecord to a RecordR

data SRecords

This is a conversion type that allows for sorting both Records and Bits. It is useful in recursive Tensort variants

Constructors

SRecordsBit [Record]

SRecordsRec [RecordR]

Instances

Show SRecords

Defined in Data.Tensort.Utils.Types

Methods

showsPrec :: Int -> SRecords -> ShowS

show :: SRecords -> String

showList :: [SRecords] -> ShowS

Eq SRecords

Defined in Data.Tensort.Utils.Types

Methods

(==) :: SRecords -> SRecords -> Bool

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

Ord SRecords

Defined in Data.Tensort.Utils.Types

Methods

compare :: SRecords -> SRecords -> Ordering

(<) :: SRecords -> SRecords -> Bool

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

(>) :: SRecords -> SRecords -> Bool

(>=) :: SRecords -> SRecords -> Bool

max :: SRecords -> SRecords -> SRecords

min :: SRecords -> SRecords -> SRecords

fromSRecordsBit :: SRecords -> [Record]

Converts an SRecords to a list of Records

fromSRecordsRec :: SRecords -> [RecordR]

Converts an SRecords to a list of RecordRs

fromSRecordArrayBit :: [SRecord] -> [Record]

Converts a list of SRecords to a list of Records

fromSRecordArrayRec :: [SRecord] -> [RecordR]

Converts a list of SRecords to a list of RecordRs

type Register = [Record]

A Register is a list of Records allowing for easy access to data in a Tensor's Memory

type RegisterR = [RecordR]

This is a Register type that is used when sorting Records in a recursive Tensort variant

data Sortable

We use a Sortable type to sort Bits and Records

Constructors

SortBit [Bit]

SortRec [Record]

Instances

Show Sortable

Defined in Data.Tensort.Utils.Types

Methods

showsPrec :: Int -> Sortable -> ShowS

show :: Sortable -> String

showList :: [Sortable] -> ShowS

Eq Sortable

Defined in Data.Tensort.Utils.Types

Methods

(==) :: Sortable -> Sortable -> Bool

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

Ord Sortable

Defined in Data.Tensort.Utils.Types

Methods

compare :: Sortable -> Sortable -> Ordering

(<) :: Sortable -> Sortable -> Bool

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

(>) :: Sortable -> Sortable -> Bool

(>=) :: Sortable -> Sortable -> Bool

max :: Sortable -> Sortable -> Sortable

min :: Sortable -> Sortable -> Sortable

fromSortBit :: Sortable -> [Bit]

Converts a Sortable list to a list of Bits

fromSortRec :: Sortable -> [Record]

Converts a Sortable list to a list of Records

fromSBitBits :: [SBit] -> Sortable

Converts a list of Bits to a Sortable

fromSBitRecs :: [SBit] -> Sortable

Converts a list of Records to a Sortable

data SBytes

This is a conversion type that allows for sorting both Bits and Records. It is useful in recursive Tensort variants

Constructors

SBytesBit [Byte]

SBytesRec [ByteR]

Instances

Show SBytes

Defined in Data.Tensort.Utils.Types

Methods

showsPrec :: Int -> SBytes -> ShowS

show :: SBytes -> String

showList :: [SBytes] -> ShowS

Eq SBytes

Defined in Data.Tensort.Utils.Types

Methods

(==) :: SBytes -> SBytes -> Bool

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

Ord SBytes

Defined in Data.Tensort.Utils.Types

Methods

compare :: SBytes -> SBytes -> Ordering

(<) :: SBytes -> SBytes -> Bool

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

(>) :: SBytes -> SBytes -> Bool

(>=) :: SBytes -> SBytes -> Bool

max :: SBytes -> SBytes -> SBytes

min :: SBytes -> SBytes -> SBytes

fromSBytesBit :: SBytes -> [[Bit]]

Converts an SBytes list to a list of Bytes

fromSBytesRec :: SBytes -> [[Record]]

Converts an SBytes list to a list of ByteRs

data STensor

This is a conversion type that allows for sorting both Bits and Records. It is useful in recursive Tensort variants

Constructors

STensorBit Tensor

STensorRec TensorR

Instances

Show STensor

Defined in Data.Tensort.Utils.Types

Methods

showsPrec :: Int -> STensor -> ShowS

show :: STensor -> String

showList :: [STensor] -> ShowS

Eq STensor

Defined in Data.Tensort.Utils.Types

Methods

(==) :: STensor -> STensor -> Bool

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

Ord STensor

Defined in Data.Tensort.Utils.Types

Methods

compare :: STensor -> STensor -> Ordering

(<) :: STensor -> STensor -> Bool

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

(>) :: STensor -> STensor -> Bool

(>=) :: STensor -> STensor -> Bool

max :: STensor -> STensor -> STensor

min :: STensor -> STensor -> STensor

data STensors

This is a conversion type that allows for sorting both Bits and Records. It is useful in recursive Tensort variants

Constructors

STensorsBit [Tensor]

STensorsRec [TensorR]

Instances

Show STensors

Defined in Data.Tensort.Utils.Types

Methods

showsPrec :: Int -> STensors -> ShowS

show :: STensors -> String

showList :: [STensors] -> ShowS

Eq STensors

Defined in Data.Tensort.Utils.Types

Methods

(==) :: STensors -> STensors -> Bool

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

Ord STensors

Defined in Data.Tensort.Utils.Types

Methods

compare :: STensors -> STensors -> Ordering

(<) :: STensors -> STensors -> Bool

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

(>) :: STensors -> STensors -> Bool

(>=) :: STensors -> STensors -> Bool

max :: STensors -> STensors -> STensors

min :: STensors -> STensors -> STensors

fromSTensorBit :: STensor -> Tensor

Converts an STensor to a Tensor

fromSTensorRec :: STensor -> TensorR

Converts an STensor to a TensorR

fromSTensorsBit :: STensors -> [Tensor]

Converts an STensors list to a list of Tensors

fromSTensorsRec :: STensors -> [TensorR]

Converts an STensors list to a list of TensorRs

type SortAlg = Sortable -> Sortable

A sorting algorithm is a function that takes a Sortable and returns a sorted Sortable

type SupersortProps = (SortAlg, SortAlg, SortAlg, SupersortStrat)

SupersortProps consist of three sorting algorithms to adjuditcate between and a SupersortStrat that does the adjudication

type SupersortStrat = (Sortable, Sortable, Sortable) -> Sortable

A SupersortStrat takes three Sortables and determines which of the three is most likely to be in the correct order

data Memory

A Memory contains the data to be sorted, either in the form of Bytes or Tensors.

Constructors

ByteMem [Byte]

TensorMem [Tensor]

Instances

Show Memory

Defined in Data.Tensort.Utils.Types

Methods

showsPrec :: Int -> Memory -> ShowS

show :: Memory -> String

showList :: [Memory] -> ShowS

Eq Memory

Defined in Data.Tensort.Utils.Types

Methods

(==) :: Memory -> Memory -> Bool

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

Ord Memory

Defined in Data.Tensort.Utils.Types

Methods

compare :: Memory -> Memory -> Ordering

(<) :: Memory -> Memory -> Bool

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

(>) :: Memory -> Memory -> Bool

(>=) :: Memory -> Memory -> Bool

max :: Memory -> Memory -> Memory

min :: Memory -> Memory -> Memory

data MemoryR

This is a Memory type that is used when sorting Records in a recursive Tensort variant

Constructors

ByteMemR [ByteR]

TensorMemR [TensorR]

Instances

Show MemoryR

Defined in Data.Tensort.Utils.Types

Methods

showsPrec :: Int -> MemoryR -> ShowS

show :: MemoryR -> String

showList :: [MemoryR] -> ShowS

Eq MemoryR

Defined in Data.Tensort.Utils.Types

Methods

(==) :: MemoryR -> MemoryR -> Bool

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

Ord MemoryR

Defined in Data.Tensort.Utils.Types

Methods

compare :: MemoryR -> MemoryR -> Ordering

(<) :: MemoryR -> MemoryR -> Bool

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

(>) :: MemoryR -> MemoryR -> Bool

(>=) :: MemoryR -> MemoryR -> Bool

max :: MemoryR -> MemoryR -> MemoryR

min :: MemoryR -> MemoryR -> MemoryR

data SMemory

This is a conversion type that allows for sorting both Bits and Records. It is useful in recursive Tensort variants

Constructors

SMemoryBit Memory

SMemoryRec MemoryR

Instances

Show SMemory

Defined in Data.Tensort.Utils.Types

Methods

showsPrec :: Int -> SMemory -> ShowS

show :: SMemory -> String

showList :: [SMemory] -> ShowS

Eq SMemory

Defined in Data.Tensort.Utils.Types

Methods

(==) :: SMemory -> SMemory -> Bool

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

Ord SMemory

Defined in Data.Tensort.Utils.Types

Methods

compare :: SMemory -> SMemory -> Ordering

(<) :: SMemory -> SMemory -> Bool

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

(>) :: SMemory -> SMemory -> Bool

(>=) :: SMemory -> SMemory -> Bool

max :: SMemory -> SMemory -> SMemory

min :: SMemory -> SMemory -> SMemory

fromSMemoryBit :: SMemory -> Memory

Converts an SMemory to a Memory

fromSMemoryRec :: SMemory -> MemoryR

Converts an SMemory to a MemoryR

type Tensor = (Register, Memory)

A Tensor contains data to be sorted in a structure allowing for easy access. It consists of a Register and its Memory.

The Memory is a list of the Bytes or other Tensors that this Tensor contains.

The Register is a list of Records referencing the top Bits in Memory.

type TensorR = (RegisterR, MemoryR)

This is a Tensor type that is used when sorting Records in a recursive Tensort variant

type TensorStack = Tensor

A TensorStack is a top-level Tensor. In the final stages of Tensort, the number of TensorStacks will be equal to (or sometimes less than) the bytesize, but before that time there are expected to be many more TensorStacks.

type TensorStackR = TensorR

This is a TensorStack type that is used when sorting Records in a recursive Tensort variant

type STensorStack = STensor

This is a conversion type that allows for sorting both Tensors and Records. It is useful in recursive Tensort variants

type STensorStacks = STensors

This is a conversion type that allows for sorting both Tensors and Records. It is useful in recursive Tensort variants

fromJust :: Maybe a -> a

Convers a Maybe into a value or throws an error if the Maybe is Nothing