Count.pine

// This Pine Script™ code is subject to the terms of the MIT License at https://opensource.org/license/mit/
// © joebaus
//@version=6

//@description Library of functions for counting the number of times (frequency) that elements occur in an array or matrix.
library("Count")



//#region Comparison Check Functions



// validOperator(string op) {
// @function                Ensures only valid comparison operators are used for `int` and `float` methods of `count()`.
// @param op                The comparison operator string to check for validity.
// @returns                 Does nothing for valid `op` parameters.
//                          Returns a `runtime.error()` message for invalid parameters.
validOperator(string op) =>
    array<string> validComparisons = array.from('==', '<', '>', '=<', '=>', '!=')
    if not validComparisons.includes(op)
        runtime.error('Count: An invalid comparison operator string was used! ' +
          "Valid operator strings are: '==', '<', '>', '=<', '=>', '!='")
// }


// comparisonCheck(int value1, string op, int value2) {
// @function                Checks if two values satisfy a comparison operator.
// @param value1            The first value to compare.
// @param op                A comparison operator. Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @param value2            The second value to compare.
// @returns                 A `bool` representing the result of the comparison.
// ___
// **Usage**
// 
//                          Check if `1` is less than `2`.
//                          ```
//                          bool cc = comparisonCheck(1, '<', 2)
//                          ```
method comparisonCheck(int value1, string op, int value2) =>
    validOperator(op)

    switch
        op == '==' => value1 == value2
        op == '!=' => value1 != value2
        op == '<' => value1 < value2
        op == '>' => value1 > value2
        op == '<=' => value1 <= value2
        op == '>=' => value1 >= value2
        => false
// }


// comparisonCheck(float value1, string op, float value2) {
// @function                Checks if two values satisfy a comparison operator.
// @param value1            The first value to compare.
// @param op                A comparison operator. Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @param value2            The second value to compare.
// @returns                 A `bool` representing the result of the comparison.
// ___
// **Usage**
// 
//                          Check if `3.5` is greater than `7.0`.
//                          ```
//                          bool cc = comparisonCheck(3.5, '>', 7.0)
//                          ```
method comparisonCheck(float value1, string op, float value2) =>
    validOperator(op)

    switch 
        op == '==' => value1 == value2
        op == '!=' => value1 != value2
        op == '<' => value1 < value2
        op == '>' => value1 > value2
        op == '<=' => value1 <= value2
        op == '>=' => value1 >= value2
        => false
// }


// comparisonCheck(bool value1, string op, bool value2) {
// @function                Checks if two values satisfy a comparison operator.
// @param value1            The first value to compare.
// @param op                A comparison operator. Valid strings: `'=='` or `'!='`.
// @param value2            The second value to compare.
// @returns                 A `bool` representing the result of the comparison.
// ___
// **Usage**
// 
//                          Check if `true` is not equal to `false`.
//                          ```
//                          bool cc = comparisonCheck(true, '!=', false)
//                          ```
method comparisonCheck(bool value1, string op, bool value2) =>
    array<string> validComparisons = array.from('==', '!=')
    if not validComparisons.includes(op)
        runtime.error('Count: An invalid comparison operator string was used! ' +
          "Valid operator strings are: '==' and '!='")

    switch
        op == '==' => value1 == value2
        op == '!=' => value1 != value2
        => false
// }



//#endregion Comparison Check Functions



//#region Array to Map Count



// count(array<int> id) {
// @function                Counts the number of times each unique element occurs within an `array<int>`.
// @param id                The array to count elements from.
// @returns                 A `map<int, int>` where the `.keys()` are unique `int` elements, 
//                          and `.values()` are each unique element's respective count as an `int`.
//___
// **Usage**
//
//                          Create a `map<int, int>` count map from an array.
//                          ```
//                          array<int> intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6)
//                          map<int, int> countMap = intArray.count()
//                          array<int> mapKeys = countMap.keys() // Returns [2, 3, 4, 6]
//                          array<int> mapValues = countMap.values() // Returns [3, 1, 5, 2]
//                          ```
export method count(array<int> id) =>
    map<int, int> countMap = map.new<int, int>()

    for i in id
        if countMap.keys().includes(i) // Check if the key already exists in the map.
            countMap.put(i, countMap.get(i) + 1) // Increment the key's value by 1.
        else // Initalize new key.
            countMap.put(i, 1)

    countMap
// }


// count(array<float> id) {
// @function                Counts the number of times each unique element occurs within an `array<float>`.
// @param id                The array to count elements from.
// @returns                 A `map<float, int>` where the `.keys()` are unique `float` elements, 
//                          and `.values()` are each unique element's respective count as an `int`.
// ___
// **Usage**
//
//                          Create a `map<float, int>` count map from an array.
//                          ```
//                          array<float> floatArray = array.from(1.00, 1.50, 1.25, 1.00, 0.75, 1.25, 1.75, 1.25)
//                          map<float, int> countMap = floatArray.count()
//                          array<float> mapKeys = countMap.keys() // Returns [1.0, 1.5, 1.25, 0.75, 1.75]
//                          array<int> mapValues = countMap.values() // Returns [2, 1, 3, 1, 1]
//                          ```
export method count(array<float> id) =>
    map<float, int> countMap = map.new<float, int>()

    for i in id
        if countMap.keys().includes(i)
            countMap.put(i, countMap.get(i) + 1)
        else
            countMap.put(i, 1)

    countMap
// }


// count(array<string> id) {
// @function                Counts the number of times each unique element occurs within an `array<string>`.
// @param id                The array to count elements from.
// @returns                 A `map<string, int>` where the `.keys()` are unique `string` elements, 
//                          and `.values()` are each unique element's respective count as an `int`.
// ___
// **Usage**
//
//                          Create a `map<string, int>` count map from an array.
//                          ```
//                          array<string> stringArray = array.from('bullish', 'bull', 'bullish', 'bear', 'bull', 'bearish', 'bearish')
//                          map<string, int> countMap = stringArray.count()
//                          array<string> mapKeys = countMap.keys() // Returns [bullish, bull, bear, bearish]
//                          array<int> mapValues = countMap.values() // Returns [2, 2, 1, 2]
//                          ```
export method count(array<string> id) =>
    map<string, int> countMap = map.new<string, int>()

    for i in id
        if countMap.keys().includes(i)
            countMap.put(i, countMap.get(i) + 1)
        else
            countMap.put(i, 1)

    countMap
// }


// count(array<bool> id) {
// @function                Counts the number of times each unique element occurs within an `array<bool>`.
// @param id                The array to count elements from.
// @returns                 A `map<bool, int>` where the `.keys()` are unique `bool` elements, 
//                          and `.values()` are each unique element's respective count as an `int`.
// ___
// **Usage**
//
//                          Create a `map<bool, int>` count map from an array.
//                          ```
//                          array<bool> boolArray = array.from(true, true, false, true, false, false, true)
//                          map<bool, int> countMap = boolArray.count()
//                          array<bool> mapKeys = countMap.keys() // Returns [true, false]
//                          array<int> mapValues = countMap.values() // Returns [4, 4]
//                          ```
export method count(array<bool> id) =>
    map<bool, int> countMap = map.new<bool, int>()

    for i in id
        if countMap.keys().includes(i)
            countMap.put(i, countMap.get(i) + 1)
        else
            countMap.put(i, 1)

    countMap
// }



//#endregion Array to Map Count



//#region Array Element Count



// count(array<int> id, int value, string op = '==') {
// @function                Counts the number of times an element occurs within an `array<int>`.
// @param id                The array to count elements from.
// @param value             The element to count.
// @param op                Optional. A comparison operator. Default is `==`. 
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 An `int` count representing the number of times `value` occurred inside the `id` array.
// ___
// **Usage**
//
//                          Count the number of times `4` occurs in an `array<int>`.
//                          ```
//                          array<int> intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6)
//                          int count = intArray.count(4) // Returns 5
//                          ```
//                          Count the number of times an element is less than `4`.
//                          ```
//                          int countComparison = intArray.count(4, '<') // Returns 4
//                          ```
export method count(array<int> id, int value, string op = '==') =>
    int count = 0

    for i in id
        if comparisonCheck(i, op, value)
            count += 1

    count
// }


// count(array<float> id, float value, string op = '==') {
// @function                Counts the number of times an element occurs within an `array<float>`.
// @param id                The array to count elements from.
// @param value             The element to count.
// @param op                Optional. A comparison operator. Default is `==`. 
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 An `int` count representing the number of times `value` occurred inside the `id` array.
// ___
// **Usage**
//
//                          Check the number of occurrences of `1.0` in an `array<float>`.
//                          ```
//                          array<float> floatArray = array.from(1.00, 1.50, 1.25, 1.00, 0.75, 1.25, 1.75, 1.25)
//                          int count = floatArray.count(1.0) // Returns 2
//                          ```
//                          Apply a comparison operator to all elements counted.
//                          ```
//                          int countComparison = floatArray.count(1.0, '>') // Returns 5
//                          ```
export method count(array<float> id, float value, string op = '==') =>
    int count = 0

    for i in id
        if comparisonCheck(i, op, value)
            count += 1

    count
// }


// count(array<string> id, string regex) {
// @function                Counts the number of times an element occurs within an `array<string>`.
// @param id                The array to count elements from.
// @param regex             The regex pattern used to count elements.
// @returns                 An `int` count of the number of times `regex` occurred inside the `id` array.
// ___
// **Usage**
//
//                          Count the number of times the string `'bullish'` occurs in an `array<string>`.
//                          ```
//                          array<string> stringArray = array.from('bullish', 'bull', 'bullish', 'bear', 'bull', 'bearish', 'bearish')
//                          int count = stringArray.count('bullish') // Returns 2
//                          ```
//                          Count the number of times the regex pattern `'bear*'` occurs in an `array<string>`.
//                          ```
//                          int countRegex = stringArray.count('bear*') // Returns 3
//                          ```
export method count(array<string> id, string regex) =>
    int count = 0

    for i in id
        if str.match(i, regex) != ''
            count += 1

    count
// }


// count(array<bool> id, bool value, string op = '==') {
// @function                Counts the number of times an element occurs within an `array<bool>`.
// @param id                The array to count elements from.
// @param value             The element to count.
// @param op                Optional. A comparison operator. Default is `==`. Valid strings: `'=='` or `'!='`.
// @returns                 An `int` of the number of times `value` occurred inside the `id` array.
// ___
// **Usage**
//
//                          Check the number of occurrences of `true` in an `array<bool>`.
//                          ```
//                          array<bool> boolArray = array.from(true, true, false, true, false, false, true)
//                          int boolCountValue = boolArray.count(true) // Returns 4
//                          ```
//                          Apply a comparison operator to all elements counted. 
//                          ```
//                          int boolCountComparison = boolArray.count(true, '!=') // Returns 3
//                          ```
export method count(array<bool> id, bool value, string op = '==') =>
    int count = 0

    for i in id
        if comparisonCheck(i, op, value)
            count += 1

    count
// }



//#endregion Array Element Count



//#region Array Elements Count



// count(array<int> id, array<int> values, string op = '==') {
// @function                Counts the number of times a set of elements occurs within an `array<int>`.
// @param id                The array to count elements from.
// @param values            The elements to count.
// @param op                Optional. A comparison operator. Default is `==`. 
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 A `map<int, int>` where the `.keys()` is an `array<int>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// ___
// **Usage**
//
//                          Count the number of times multiple elements occur in an array.
//                          ```
//                          array<int> intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6)
//                          array<int> intValues = array.from(2, 4)
//                          
//                          map<int, int> countMap = intArray.count(intValues)
//                          array<int> mapKeys = countMap.keys() // Returns [2, 4]
//                          array<int> mapValues = countMap.values() // Returns [3, 5]
//                          ```
//                          Apply a comparison operator to all elements counted.
//                          ```
//                          map<int, int> countMap = intArray.count(intValues, '<')
//                          array<int> mapKeys = countMap.keys() // Returns [2, 4]
//                          array<int> mapValues = countMap.values() // Returns [0, 4]
//                          ```
export method count(array<int> id, array<int> values, string op = '==') =>
    map<int, int> countMap = map.new<int, int>()

    for i in id
        for value in values
            if countMap.keys().includes(value)
                int count = countMap.get(value)
    
                if comparisonCheck(i, op, value)
                    count += 1
    
                countMap.put(value, count)
            else
                countMap.put(value, 1)

    countMap
// }


// count(array<int> id, array<int> values, array<string> ops) {
// @function                Counts the number of times a set of elements occurs within an `array<int>`.
// @param id                The array to count elements from.
// @param values            The elements to count.
// @param ops               The comparison operator for each `values` element.
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 A `map<int, int>` where the `.keys()` is an `array<int>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// 
//                          Returns a runtime error if `values` is not the same size as `ops`.
// ___
// **Usage**
//
//                          Count the number of times multiple elements occur in an array.
//                          ```
//                          array<int> intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6)
//                          array<int> intValues = array.from(2, 4)
//                          
//                          map<int, int> countMap = intArray.count(intValues)
//                          array<int> mapKeys = countMap.keys() // Returns [2, 4]
//                          array<int> mapValues = countMap.values() // Returns [3, 5]
//                          ```
//                          Apply a unique comparison operator to each value counted.
//                          ```
//                          array<string> comparisons = array.from('>', '==')
// 
//                          map<int, int> countMap = intArray.count(intValues, comparisons)
//                          array<int> mapKeys = countMap.keys() // Returns [2, 3]
//                          array<int> mapValues = countMap.values() // Returns [8, 1]
//                          ```
export method count(array<int> id, array<int> values, array<string> ops) =>
    if values.size() != ops.size()
        runtime.error('count(array<int> id, array<int> values, array<string> ops): ' + 
          '`values` and `ops` must be the same size!')

    map<int, int> countMap = map.new<int, int>()

    for i in id
        for [j, value] in values
            if countMap.keys().includes(value)
                int count = countMap.get(value)
                string op = ops.get(j)
    
                if comparisonCheck(i, op, value)
                    count += 1
    
                countMap.put(value, count)
            else
                countMap.put(value, 1)

    countMap
// }


// count(array<float> id, array<float> values, string op = '==') {
// @function                Counts the number of times a set of elements occurs within an `array<float>`.
// @param id                The array to count elements from.
// @param values            The elements to count.
// @param op                Optional. A comparison operator. Default is `==`.
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 A `map<float, int>` where the `.keys()` is an `array<float>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// ___
// **Usage**
//
//                          Count the number of times multiple elements occur in an array.
//                          ```
//                          array<float> floatArray = array.from(1.00, 1.50, 1.25, 1.00, 0.75, 1.25, 1.75, 1.25)
//                          array<float> floatValues = array.from(1.00, 1.25)
//                          
//                          map<float, int> countMap = floatArray.count(floatValues)
//                          array<float> mapKeys = countMap.keys() // Returns [1.00, 1.25]
//                          array<int> mapValues = countMap.values() // Returns [2, 3]
//                          ```
//                          Apply a comparison operator to all elements counted.
//                          ```
//                          map<float, int> countMap = floatArray.count(floatValues, '<')
//                          array<float> mapKeys = countMap.keys() // Returns [1.00, 1.25]
//                          array<int> mapValues = countMap.values() // Returns [1, 3]
//                          ```
export method count(array<float> id, array<float> values, string op = '==') =>
    map<float, int> countMap = map.new<float, int>()

    for i in id
        for value in values
            if countMap.keys().includes(value)
                int count = countMap.get(value)
    
                if comparisonCheck(i, op, value)
                    count += 1
    
                countMap.put(value, count)
            else
                countMap.put(value, 1)

    countMap
// }


// count(array<float> id, array<float> values, array<string> ops) {
// @function                Counts the number of times a set of elements occurs within an `array<float>`.
// @param id                The array to count elements from.
// @param values            The elements to count.
// @param ops               The comparison operator for each `values` element.
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 A `map<float, int>` where the `.keys()` is an `array<float>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// 
//                          Returns a runtime error if `values` is not the same size as `ops`.
// ___
// **Usage**
//
//                          Count the number of times multiple elements occur in an array.
//                          ```
//                          array<float> floatArray = array.from(1.00, 1.50, 1.25, 1.00, 0.75, 1.25, 1.75, 1.25)
//                          array<float> floatValues = array.from(1.00, 1.25)
//                          
//                          map<float, int> countMap = floatArray.count(floatValues)
//                          array<float> mapKeys = countMap.keys() // Returns [1.00, 1.25]
//                          array<int> mapValues = countMap.values() // Returns [2, 3]
//                          ```
//                          Apply a unique comparison operator to each value counted.
//                          ```
//                          array<string> comparisons = array.from('>', '==')
//
//                          map<float, int> countMap = floatArray.count(floatValues, comparisons)
//                          array<float> mapKeys = countMap.keys() // Returns [1.00, 1.25]
//                          array<int> mapValues = countMap.values() // Returns [5, 2]
//                          ```
export method count(array<float> id, array<float> values, array<string> ops) =>
    if values.size() != ops.size()
        runtime.error('count(array<float> id, array<float> values, array<string> ops): ' + 
          '`values` and `ops` must be the same size!')

    map<float, int> countMap = map.new<float, int>()

    for i in id
        for [j, value] in values
            if countMap.keys().includes(value)
                int count = countMap.get(value)
                string op  = ops.get(j)
    
                if comparisonCheck(i, op, value)
                    count += 1
    
                countMap.put(value, count)
            else
                countMap.put(value, 1)

    countMap
// }


// count(array<string> id, array<string> regexes) {
// @function                Counts the number of times a set of regex patterns occurs within an `array<string>`.
// @param id                The array to count elements from.
// @param regexes           The regex patterns used to count elements.
// @returns                 A `map<string, int>` where the `.keys()` is an `array<string>` of each unique `regexes` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// ___
// **Usage**
//
//                          Count the number of element in `stringArray` that match an array of regex patterns.
//                          ```
//                          array<string> stringArray = array.from('bullish', 'bull', 'bullish', 'bearish', 'bull', 'bearish', 'bearish')
//                          array<string> stringValues = array.from('bull*', 'bear*')
//                          
//                          map<string, int> countMap = stringArray.count(stringValues)
//                          array<string> mapKeys countMap.keys() // Returns ['bull*', 'bear*']
//                          array<int> mapValues countMap.values() // Returns [4, 3]
//                          ```
export method count(array<string> id, array<string> regexes) =>
    map<string, int> countMap = map.new<string, int>()

    for i in id
        for regex in regexes
            if countMap.keys().includes(regex)
                if str.match(i, regex) != ''
                    countMap.put(regex, countMap.get(regex) + 1)
            else
                countMap.put(regex, 1)

    countMap
// }


// count(array<bool> id, array<bool> values, string op = '==') {
// @function                Counts the number of times a set of elements occurs within an `array<bool>`.
// @param id                The array to count elements from.
// @param values            The elements to count.
// @param op                Optional. A comparison operator. Default is `==`. Valid strings: `'=='` or `'!='`.
// @returns                 A `map<bool, int>` where the `.keys()` is an `array<bool>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// ___
// **Usage**
//
//                          Count the number of times multiple elements occur in an array.
//                          ```
//                          array<bool> boolArray = array.from(true, true, false, true, false, false, true)
//                          array<bool> boolValues = array.from(true, false)
//                          
//                          map<bool, int> countMap = boolArray.count(boolValues)
//                          array<bool> mapKeys = boolArray.keys() // Returns [true, false]
//                          array<int> mapValues = boolArray.values() // Returns [4, 3]
//                          ```
//                          Apply a comparison operator to all elements counted.
//                          ```
//                          map<bool, int> countMap = boolArray.count(boolValues, '<')
//                          array<bool> mapKeys = countMap.keys() // Returns [true, false]
//                          array<int> mapValues = countMap.values() // Returns [0, 3]
//                          ```
export method count(array<bool> id, array<bool> values, string op = '==') =>
    map<bool, int> countMap = map.new<bool, int>()

    for i in id
        for value in values
            if countMap.keys().includes(value)
                int count = countMap.get(value)
    
                if comparisonCheck(i, op, value)
                    count += 1
    
                countMap.put(value, count)
            else
                countMap.put(value, 1)

    countMap
// }


// count(array<bool> id, array<bool> values, array<string> ops) {
// @function                Counts the number of times an element occurs within an `array<bool>`.
// @param id                The array to count elements from.
// @param values            The elements to count.
// @param ops               The comparison operator for each `values` element. Valid strings: `'=='` or `'!='`.
// @returns                 A `map<bool, int>` where the `.keys()` is an `array<bool>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// 
//                          Returns a runtime error if `values` is not the same size as `ops`.
// ___
// **Usage**
//
//                          Count the number of times multiple elements occur in an array.
//                          ```
//                          array<bool> boolArray = array.from(true, true, false, true, false, false, true)
//                          array<bool> boolValues = array.from(true, false)
//                          
//                          map<bool, int> countMap = boolArray.count(boolValues)
//                          array<bool> mapKeys = countMap.keys() // Returns [true, false]
//                          array<int> mapValues = countMap.values() // Returns [4, 3]
//                          ```
//                          Apply a unique comparison operator to each value counted.
//                          ```
//                          array<string> comparisons = array.from('!=', '==')
// 
//                          map<bool, int> countMap = boolArray.count(boolValues, comparisons)
//                          array<bool> mapKeys = countMap.keys() // Returns [true, false]
//                          array<int> mapValues = countMap.values() // Returns [3, 3]
//                          ```
export method count(array<bool> id, array<bool> values, array<string> ops) =>
    if values.size() != ops.size()
        runtime.error('count(array<bool> id, array<bool> values, array<string> ops): ' + 
          '`values` and `ops` must be the same size!')

    map<bool, int> countMap = map.new<bool, int>()

    for i in id
        for [j, value] in values
            if countMap.keys().includes(value)
                int count = countMap.get(value)
                string op = ops.get(j)
    
                if comparisonCheck(i, op, value)
                    count += 1
    
                countMap.put(value, count)
            else
                countMap.put(value, 1)

    countMap
// }



//#endregion Array Elements Count



//#region Matrix to Map Count



// count(matrix<int> id) {
// @function                Counts the number of times each unique element occurs within a `matrix<int>`.
// @param id                The matrix to count elements from.
// @returns                 A `map<int, int>` where the `.keys()` are unique `int` elements, 
//                          and `.values()` are each unique element's respective count as an `int`.
// ___
// **Usage**
//
//                          Create a `map<int, int>` count map from a matrix. 
//                          ```
//                          matrix<int> intMatrix = matrix.new<int>(3, 3, 1)
//                          intMatrix.set(0, 0, 2), intMatrix.set(1, 0, 3), intMatrix.set(2, 0, 5)
//                          intMatrix.set(0, 1, 2), intMatrix.set(1, 1, 4), intMatrix.set(2, 1, 2)
//                          intMatrix.set(0, 2, 5), intMatrix.set(1, 2, 2), intMatrix.set(2, 2, 3)
//
//                          map<int, int> intMatrixCountMap = intMatrix.count()
//                          array<int> mapKeys = intMatrixCountMap.keys() // Returns [2, 3, 4, 5]
//                          array<int> mapValues = intMatrixCountMap.values() // Returns [4, 2, 1, 2]
//                          ```
export method count(matrix<int> id) =>
    map<int, int> countMap = map.new<int, int>()

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            int element = id.get(row, col)

            if countMap.keys().includes(element)
                countMap.put(element, countMap.get(element) + 1)
            else
                countMap.put(element, 1)

    countMap
// }


// count(matrix<float> id) {
// @function                Counts the number of times each unique element occurs within a `matrix<float>`.
// @param id                The matrix to count elements from.
// @returns                 A `map<float, int>` where the `.keys()` are unique `float` elements, 
//                          and the `.value`  object is that element's count as an `int`.
// ___
// **Usage**
//
//                          Create a `map<float, int>` count map from a matrix.
//                          ```
//                          matrix<float> floatMatrix = matrix.new<float>(3, 3, 0.0)
//                          floatMatrix.set(0, 0, 1.0), floatMatrix.set(1, 0, 1.0), floatMatrix.set(2, 0, 1.0)
//                          floatMatrix.set(0, 1, 1.5), floatMatrix.set(1, 1, 2.0), floatMatrix.set(2, 1, 2.5)
//                          floatMatrix.set(0, 2, 1.0), floatMatrix.set(1, 2, 2.5), floatMatrix.set(2, 2, 1.5)
//
//                          map<float, int> floatMatrixCountMap = floatMatrix.count()
//                          array<float> mapKeys = floatMatrixCountMap.keys() // Returns [1.0, 1.5, 2.0, 2.5]
//                          array<int> mapValues = floatMatrixCountMap.values() // Returns [3, 2, 1, 2]
//                          ```
export method count(matrix<float> id) =>
    map<float, int> countMap = map.new<float, int>()

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            float element = id.get(row, col)

            if countMap.keys().includes(element)
                countMap.put(element, countMap.get(element) + 1)
            else
                countMap.put(element, 1)
    
    countMap
// }


// count(matrix<string> id) {
// @function                Counts the number of times each unique element occurs within a `matrix<string>`.
// @param id                The matrix to count elements from.
// @returns                 A `map<string, int>` where the `.keys()` are unique `string` elements, 
//                          and `.values()` are each unique element's respective count as an `int`.
// ___
// **Usage**
//
//                          Create a `map<string, int>` count map from a matrix.
//                          ```
//                          matrix<string> stringMatrix = matrix.new<string>(3, 3, '')
//                          stringMatrix.set(0, 0, 'a'), stringMatrix.set(1, 0, 'a'), stringMatrix.set(2, 0, 'a')
//                          stringMatrix.set(0, 1, 'b'), stringMatrix.set(1, 1, 'c'), stringMatrix.set(2, 1, 'd')
//                          stringMatrix.set(0, 2, 'a'), stringMatrix.set(1, 2, 'd'), stringMatrix.set(2, 2, 'b')
//
//                          map<string, int> stringMatrixCountMap = stringMatrix.count()
//                          array<string> mapKeys = stringMatrixCountMap.keys(): ['a', 'b', 'c', 'd']
//                          array<int> mapValues = stringMatrixCountMap.values() // Returns [3, 2, 1, 2]
//                          ```
export method count(matrix<string> id) =>
    map<string, int> countMap = map.new<string, int>()

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            string element = id.get(row, col)

            if countMap.keys().includes(element)
                countMap.put(element, countMap.get(element) + 1)
            else
                countMap.put(element, 1)

    countMap
// }


// count(matrix<bool> id) {
// @function                Counts the number of times each unique element occurs within a `matrix<bool>`.
// @param id                The matrix to count elements from.
// @returns                 A `map<bool, int>` where the `.keys()` are unique `bool` elements, 
//                          and `.values()` are each unique element's respective count as an `int`.
// ___
// **Usage**
//
//                          Create a `map<bool, int>` count map from a matrix.
//                          ```
//                          matrix<bool> boolMatrix = matrix.new<bool>(3, 3, false)
//                          boolMatrix.set(0, 0, true), boolMatrix.set(1, 0, true), boolMatrix.set(2, 0, true)
//                          boolMatrix.set(0, 1, false), boolMatrix.set(1, 1, false), boolMatrix.set(2, 1, false)
//                          boolMatrix.set(0, 2, true), boolMatrix.set(1, 2, false), boolMatrix.set(2, 2, true)
//                          
//                          map<bool, int> boolMatrixCountMap = boolMatrix.count()
//                          array<bool> mapKeys = boolMatrixCountMap.keys(): [true, false]
//                          array<bool> mapValues = boolMatrixCountMap.values(): [5, 4]
//                          ```
export method count(matrix<bool> id) =>
    map<bool, int> countMap = map.new<bool, int>()

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            bool element = id.get(row, col)

            if countMap.keys().includes(element)
                countMap.put(element, countMap.get(element) + 1)
            else
                countMap.put(element, 1)

    countMap
// }



//#endregion Matrix to Map Count



//#region Element Matrix Count



// count(matrix<int> id, int value, string op = '==') {
// @function                Counts the number of times an element occurs within a `matrix<int>`.
// @param id                The matrix to count elements from.
// @param value             The element to count.
// @param op                Optional. A comparison operator. Default is `==`.
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 An `int` count of the number of times `value` occurred inside the `id` matrix.
// ___
// **Usage**
//
//                          Count the number of times `4` occurs in a `matrix<int>`.
//                          ```
//                          matrix<int> intMatrix = matrix.new<int>(3, 3, 1)
//                          intMatrix.set(0, 0, 2), intMatrix.set(1, 0, 3), intMatrix.set(2, 0, 5)
//                          intMatrix.set(0, 1, 2), intMatrix.set(1, 1, 4), intMatrix.set(2, 1, 2)
//                          intMatrix.set(0, 2, 5), intMatrix.set(1, 2, 2), intMatrix.set(2, 2, 3)
//                          
//                          int intMatrixCount = intMatrix.count(4) // Returns 5
//                          ```
//                          Count the number of times an element is less than `4`.
//                          ```
//                          int intMatrixCountComparison = intMatrix.count(4, '<') // Returns 5
//                          ```
export method count(matrix<int> id, int value, string op = '==') =>
    int count = 0

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            int element = id.get(row, col)

            if comparisonCheck(element, op, value)
                count += 1

    count
// }


// count(matrix<float> id, float value, string op = '==') {
// @function                Counts the number of times an element occurs within a `matrix<float>`.
// @param id                The matrix to count elements from.
// @param value             The element to count.
// @param op                Optional. A comparison operator. Default is `==`.
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 An `int` count of the number of times `value` occurred inside the `id` matrix.
// ___
// **Usage**
//
//                          Count the number of times `4` occurs in a `matrix<float>`.
//                          ```
//                          matrix<float> floatMatrix = matrix.new<float>(3, 3, 0.0)
//                          floatMatrix.set(0, 0, 1.0), floatMatrix.set(1, 0, 1.0), floatMatrix.set(2, 0, 1.0)
//                          floatMatrix.set(0, 1, 1.5), floatMatrix.set(1, 1, 2.0), floatMatrix.set(2, 1, 2.5)
//                          floatMatrix.set(0, 2, 1.0), floatMatrix.set(1, 2, 2.5), floatMatrix.set(2, 2, 1.5)
//                          
//                          int floatMatrixCount = matrixFloat.count(4)
//                          ```
//                          Count the number of times an element is less than `4`.
//                          ```
//                          int floatMatrixCountComparison = floatMatrix.count(1.0, '>') // Returns 5
//                          ```
export method count(matrix<float> id, float value, string op = '==') =>
    int count = 0

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            float element = id.get(row, col)

            if comparisonCheck(element, op, value)
                count += 1
            
    count
// }


// count(matrix<string> id, string regex) {
// @function                Counts the number of times an element occurs within a `matrix<string>`.
// @param id                The matrix to count elements from.
// @param regex             The regex to count.
// @returns                 An `int` count of the number of times `regex` occurred inside the `id` matrix.
// ___
// **Usage**
//
//                          Count the number of times `'a'` occurs in a `matrix<string>`.
//                          ```
//                          matrix<string> stringMatrix = matrix.new<string>(3, 3, '')
//                          stringMatrix.set(0, 0, 'a'), stringMatrix.set(1, 0, 'a'), stringMatrix.set(2, 0, 'a')
//                          stringMatrix.set(0, 1, 'b'), stringMatrix.set(1, 1, 'c'), stringMatrix.set(2, 1, 'd')
//                          stringMatrix.set(0, 2, 'a'), stringMatrix.set(1, 2, 'd'), stringMatrix.set(2, 2, 'b')
//                          
//                          int stringMatrixCount = stringMatrix.count('a') // Returns 3
//                          ```
export method count(matrix<string> id, string regex) =>
    int count = 0

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            if str.match(id.get(row, col), regex) != ''
                count += 1

    count
// }


// count(matrix<bool> id, bool value, string op = '==') {
// @function                Counts the number of times an element occurs within a `matrix<bool>`.
// @param id                The matrix to count elements from.
// @param value             The `bool` value to count occurrences of.
// @param op                Optional. A comparison operator. Default is `==`. Valid strings: '=='` or `'!='`.
// @returns                 An `int` of the number of times `value` occurred in the matrix.
// ___
// **Usage**
//
//                          Count the number of times `true` occurs in a `matrix<bool>`.
//                          ```
//                          matrix<bool> boolMatrix = matrix.new<bool>(3, 3, false)
//                          boolMatrix.set(0, 0, true), boolMatrix.set(1, 0, true), boolMatrix.set(2, 0, true)
//                          boolMatrix.set(0, 1, false), boolMatrix.set(1, 1, false), boolMatrix.set(2, 1, false)
//                          boolMatrix.set(0, 2, true), boolMatrix.set(1, 2, false), boolMatrix.set(2, 2, true)
//                          
//                          int boolMatrixCount = boolMatrix.count(true) // Returns 5
//                          ```
//                          Count the number of times an element is not `true`.
//                          ```
//                          int boolMatrixCountComparison = boolMatrix.count(true, '!=') // Returns 4
//                          ```
export method count(matrix<bool> id, bool value, string op = '==') =>
    int count = 0

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            bool element = id.get(row, col)

            if comparisonCheck(element, op, value)
                count += 1

    count
// }



//#endregion Element Matrix Count



//#region Elements Matrix Count



// count(matrix<int> id, array<int> values, string op = '==') {
// @function                Counts the number of times a set of elements occurs within a `matrix<int>`.
// @param id                The matrix to count elements from.
// @param values            The elements to count.
// @param op                Optional. A comparison operator. Default is `==`. 
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 A `map<int, int>` where the `.keys()` is an `array<int>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// ___
// **Usage**
//
//                          Count the number of times `4` and `2` occur in a `matrix<int>`.
//                          ```
//                          matrix<int> intMatrix = matrix.new<int>(3, 3, 1)
//                          intMatrix.set(0, 0, 2), intMatrix.set(1, 0, 3), intMatrix.set(2, 0, 5)
//                          intMatrix.set(0, 1, 2), intMatrix.set(1, 1, 4), intMatrix.set(2, 1, 2)
//                          intMatrix.set(0, 2, 5), intMatrix.set(1, 2, 2), intMatrix.set(2, 2, 3)
//                          
//                          array<int> values = arary.from(4, 2)
//                          map<int, int> intMatrixCountMap = boolMatrix.count(values) 
//                          array<int> mapKeys = intMatrixCountMap.keys() // Returns [4, 2]
//                          array<int> mapValues = intMatrixCountMap.values() // Returns [1, 4]
//                          ```
//                          Count the number of times an element in the matrix is greater than `4` and `2`. 
//                          ```
//                          map<int, int> intMatrixCountMap = boolMatrix.count(values, '>') 
//                          array<int> mapKeys = intMatrixCountMap.keys() // Returns [4, 2]
//                          array<int> mapValues = intMatrixCountMap.values() // Returns [1, 5]
//                          ```
export method count(matrix<int> id, array<int> values, string op = '==') =>
    map<int, int> countMap = map.new<int, int>()

    for row = 0 to id.rows() - 1 // Iterate through matrix.
        for col = 0 to id.columns() - 1
            int element = id.get(row, col)
            
            for value in values // Iterate through values.
                if countMap.keys().includes(value) // Key exists.
                    int count = countMap.get(value)

                    if comparisonCheck(element, op, value)
                        count += 1

                    countMap.put(value, count)
                else // Initalize new key.
                    countMap.put(value, 1)

    countMap
// }


// count(matrix<int> id, array<int> values, array<string> ops) {
// @function                Counts the number of times a set of elements occurs within a `matrix<int>`.
// @param id                The matrix to count elements from.
// @param values            The elements to count.
// @param ops               The comparison operator for each `values` element.
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 A `map<int, int>` where the `.keys()` is an `array<int>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// 
//                          Returns a runtime error if `values` is not the same size as `ops`.
// ___
// **Usage**
//
//                          Count the number of times `4` and `2` occur in a `matrix<int>`.
//                          ```
//                          matrix<int> intMatrix = matrix.new<int>(3, 3, 1)
//                          intMatrix.set(0, 0, 2), intMatrix.set(1, 0, 3), intMatrix.set(2, 0, 5)
//                          intMatrix.set(0, 1, 2), intMatrix.set(1, 1, 4), intMatrix.set(2, 1, 2)
//                          intMatrix.set(0, 2, 5), intMatrix.set(1, 2, 2), intMatrix.set(2, 2, 3)
//                          
//                          array<int> values = arary.from(4, 2)
//                          map<int, int> intMatrixCountMap = boolMatrix.count(values) 
//                          array<int> mapKeys = intMatrixCountMap.keys() // Returns [4, 2]
//                          array<int> mapValues = intMatrixCountMap.values() // Returns [1, 4]
//                          ```
//                          Count the number of times an element in the matrix is greater than `4` and when elements equal `2`.
//                          ```
//                          array<int> comparisons = arary.from('>', '==')
//                          map<int, int> intMatrixCountMap = boolMatrix.count(values, comparisons) 
//                          array<int> mapKeys = intMatrixCountMap.keys() // Returns [4, 2]
//                          array<int> mapValues = intMatrixCountMap.values() // Returns [2, 4]
//                          ```
export method count(matrix<int> id, array<int> values, array<string> ops) =>
    map<int, int> countMap = map.new<int, int>()

    for row = 0 to id.rows() - 1 // Iterate through matrix.
        for col = 0 to id.columns() - 1
            int element = id.get(row, col)
            
            for [i, value] in values // Iterate through values.
                if countMap.keys().includes(value)
                    int count = countMap.get(value)
                    string op = ops.get(i) // Get respective comparison operator

                    if comparisonCheck(element, op, value)
                        count += 1
    
                    countMap.put(value, count)
                else
                    countMap.put(value, 1)

    countMap
// }


// count(matrix<float> id, array<float values, string op = '==') {
// @function                Counts the number of times a set of element occurs within a `matrix<float>`.
// @param id                The matrix to count elements from.
// @param values            The elements to count.
// @param op                Optional. A comparison operator. Default is `==`.
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 A `map<float, int>` where the `.keys()` is an `array<float>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// ___
// **Usage**
//
//                          Count the number of times `1.5` and `2.5` occur in a `matrix<float>`.
//                          ```
//                          matrix<float> floatMatrix = matrix.new<float>(3, 3, 0.0)
//                          floatMatrix.set(0, 0, 1.0), floatMatrix.set(1, 0, 1.0), floatMatrix.set(2, 0, 1.0)
//                          floatMatrix.set(0, 1, 1.5), floatMatrix.set(1, 1, 2.0), floatMatrix.set(2, 1, 2.5)
//                          floatMatrix.set(0, 2, 1.0), floatMatrix.set(1, 2, 2.5), floatMatrix.set(2, 2, 1.5)
//                          
//                          array<float> values = arary.from(1.5, 2.5)
//                          map<float, int> floatMatrixCountMap = floatMatrix.count(values) 
//                          array<float> mapKeys = floatMatrixCountMap.keys() // Returns [1.5, 2.5]
//                          array<int> mapValues = floatMatrixCountMap.values() // Returns [2, 2]
//                          ```
//                          Count the number of times an element in the matrix is greater than `1.5` and `2.5`. 
//                          ```
//                          map<float, int> floatMatrixCountMap = floatMatrix.count(values, '>') 
//                          array<float> mapKeys = floatMatrixCountMap.keys() // Returns [1.5, 2.5]
//                          array<int> mapValues = floatMatrixCountMap.values() // Returns [3, 0]
//                          ```
export method count(matrix<float> id, array<float> values, string op = '==') =>
    map<float, int> countMap = map.new<float, int>()

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            float element = id.get(row, col)

            for value in values
                if countMap.keys().includes(value)
                    int count = countMap.get(value)

                    if comparisonCheck(element, op, value)
                        count += 1

                    countMap.put(value, count)
                else
                    countMap.put(value, 1)

    countMap
// }


// count(matrix<float> id, array<float> values, array<string> ops) {
// @function                Counts the number of times a set of element occurs within a `matrix<float>`.
// @param id                The matrix to count elements from.
// @param values            The elements to count.
// @param ops               The comparison operator for each `values` element.
//                          Valid strings: `'=='`, `'<'`, `'>'`, `'<='`, `'>='`, or `'!='`.
// @returns                 A `map<float, int>` where the `.keys()` is an `array<float>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// 
//                          Returns a runtime error if `values` is not the same size as `ops`.
// ___
// **Usage**
//
//                          Count the number of times `1.5` and `2.5` occur in a `matrix<float>`.
//                          ```
//                          matrix<float> floatMatrix = matrix.new<float>(3, 3, 0.0)
//                          floatMatrix.set(0, 0, 1.0), floatMatrix.set(1, 0, 1.0), floatMatrix.set(2, 0, 1.0)
//                          floatMatrix.set(0, 1, 1.5), floatMatrix.set(1, 1, 2.0), floatMatrix.set(2, 1, 2.5)
//                          floatMatrix.set(0, 2, 1.0), floatMatrix.set(1, 2, 2.5), floatMatrix.set(2, 2, 1.5)
//                          
//                          array<float> values = arary.from(1.5, 2.5)
//                          map<float, int> floatMatrixCountMap = floatMatrix.count(values) 
//                          array<float> mapKeys = floatMatrixCountMap.keys() // Returns [1.5, 2.5]
//                          array<int> mapValues = floatMatrixCountMap.values() // Returns [2, 2]
//                          ```
//                          Count the number of times an element in the matrix is greater than `1.5` and `2.5`. 
//                          ```
//                          map<float, int> floatMatrixCountMap = floatMatrix.count(values, '>') 
//                          array<float> mapKeys = floatMatrixCountMap.keys() // Returns [1.5, 2.5]
//                          array<int> mapValues = floatMatrixCountMap.values() // Returns [3, 0]
//                          ```
export method count(matrix<float> id, array<float> values, array<string> ops) =>
    map<float, int> countMap = map.new<float, int>()

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            float element = id.get(row, col)

            for [i, value] in values
                if countMap.keys().includes(value)
                    int count = countMap.get(value)
                    string op = ops.get(i)

                    if comparisonCheck(element, op, value)
                        count += 1

                    countMap.put(value, count)
                else
                    countMap.put(value, 1)

    countMap
// }


// count(matrix<string> id, array<string> regexes) {
// @function                Counts the number of times a set of element occurs within a `matrix<string>`.
// @param id                The matrix to count elements from.
// @param regexes           The regexes to count.
// @returns                 A `map<string, int>` where the `.keys()` is an `array<string>` of each unique `regexes` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// ___
// **Usage**
//
//                          Count the number of times the string `'a'` occurs in a `matrix<string>`.
//                          ```
//                          matrix<string> stringMatrix = matrix.new<string>(3, 3, "")
//                          stringMatrix.set(0, 0, 'a'), stringMatrix.set(1, 0, 'a'), stringMatrix.set(2, 0, 'a')
//                          stringMatrix.set(0, 1, 'b'), stringMatrix.set(1, 1, 'c'), stringMatrix.set(2, 1, 'd')
//                          stringMatrix.set(0, 2, 'a'), stringMatrix.set(1, 2, 'd'), stringMatrix.set(2, 2, 'b')
//                          
//                          int stringMatrixCount = stringMatrix.count('a') // Returns 3
//                          ```
//                          Count the number of times the regex pattern `'^(b|d)$'` occurs in a `matrix<string>`.
//                          ```
//                          int stringMatrixCount = stringMatrix.count('^(b|d)$') // Returns 4
//                          ```
//                          Count the number of times both regex patterns, `'^(a|c)$'` and `'^(b|d)$'`, occur in a `matrix<string>`.
//                          ```
//                          array<string> regexes = array.from('^(a|c)$', '^(b|d)$')
//                          map<string, int> stringMatrixCountMap = stringMatrix.count(regexes)
//                          array<string> stringMatrixCountKeys = stringMatrixCountMap.keys() // ['^(a|c)$', '^(b|d)$']
//                          array<int> stringMatrixCountValues = stringMatrixCountMap.values() // Returns [5, 4]
//                          ```
export method count(matrix<string> id, array<string> regexes) =>
    map<string, int> countMap = map.new<string, int>()

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            string element = id.get(row, col)

            for regex in regexes
                if countMap.keys().includes(regex)
                    int count = countMap.get(regex)

                    if str.match(element, regex) != ''
                        count += 1

                    countMap.put(regex, count)
                else
                    countMap.put(regex, 1)

    countMap
// }


// count(matrix<bool> id, array<bool> values, string op = '==') {
// @function                Counts the number of times a set of element occurs within a `matrix<bool>`.
// @param id                The matrix to count elements from.
// @param values            The elements to count.
// @param op                Optional. A comparison operator. Default is `==`. Valid strings: `'!='`. `'=='` or `'!='`.
// @returns                 A `map<string, int>` where the `.keys()` is an `array<bool>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// ___
// **Usage**
//
//                          Count the number of times `true` and `false` occur in a `matrix<bool>`.
//                          ```
//                          matrix<bool> boolMatrix = matrix.new<bool>(3, 3, false)
//                          boolMatrix.set(0, 0, true), boolMatrix.set(1, 0, true), boolMatrix.set(2, 0, true)
//                          boolMatrix.set(0, 1, false), boolMatrix.set(1, 1, false), boolMatrix.set(2, 1, false)
//                          boolMatrix.set(0, 2, true), boolMatrix.set(1, 2, false), boolMatrix.set(2, 2, true)
//                          
//                          array<bool> values = arary.from(true, false)
//                          map<bool, int> boolMatrixCountMap = boolMatrix.count(values)
//                          array<bool> mapKeys = boolMatrixCountMap.keys() // Returns [true, false]
//                          array<int> mapValues = boolMatrixCountMap.values() // Returns [5, 4]
//                          ```
//                          Count the number of times an element in the matrix is not equal to `true` and `false`. 
//                          ```
//                          map<bool, int> boolMatrixCountMap = boolMatrix.count(values, '!=')
//                          array<bool> mapKeys = boolMatrixCountMap.keys() // Returns [true, false]
//                          array<int> mapValues = boolMatrixCountMap.values() // Returns [4, 5]
//                          ```
export method count(matrix<bool> id, array<bool> values, string op = '==') =>
    map<bool, int> countMap = map.new<bool, int>()

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            bool element = id.get(row, col)

            for value in values
                if countMap.keys().includes(value)
                    int count = countMap.get(value)
    
                    if comparisonCheck(element, op, value)
                        count += 1
    
                    countMap.put(value, count)
                else
                    countMap.put(value, 1)

    countMap
// }


// count(matrix<bool> id, array<bool> values, array<string> ops) {
// @function                Counts the number of times a set of element occurs within a `matrix<bool>`.
// @param id                The matrix to count elements from.
// @param values            The elements to count.
// @param ops               The comparison operator for each `values` element. Valid strings: `'=='` or `'!='`.
// @returns                 A `map<string, int>` where the `.keys()` is an `array<bool>` of each unique `values` element, 
//                          and `.values()` is an `array<int> of the number of times each element was counted.
// 
//                          Returns a runtime error if `values` is not the same size as `ops`.
// ___
// **Usage**
//
//                          Count the number of times `true` and `false` occur in a `matrix<bool>`.
//                          ```
//                          matrix<bool> boolMatrix = matrix.new<bool>(3, 3, false)
//                          boolMatrix.set(0, 0, true), boolMatrix.set(1, 0, true), boolMatrix.set(2, 0, true)
//                          boolMatrix.set(0, 1, false), boolMatrix.set(1, 1, false), boolMatrix.set(2, 1, false)
//                          boolMatrix.set(0, 2, true), boolMatrix.set(1, 2, false), boolMatrix.set(2, 2, true)
//                          
//                          array<bool> values = arary.from(true, false)
//                          map<bool, int> boolMatrixCountMap = boolMatrix.count(values)
//                          array<bool> mapKeys = boolMatrixCountMap.keys() // Returns [true, false]
//                          array<int> mapValues = boolMatrixCountMap.values() // Returns [5, 4]
//                          ```
//                          Count the number of times an element is equal to `true` and an element is not equal to `false`.
//                          ```
//                          array<string> comparisons = array.from('==', '!=')
//                          map<bool, int> boolMatrixCountMap = boolMatrix.count(values, comparisons)
//                          array<bool> mapKeys = boolMatrixCountMap.keys() // Returns [true, false]
//                          array<int> mapValues = boolMatrixCountMap.values() // Returns [5, 5]
//                          ```
export method count(matrix<bool> id, array<bool> values, array<string> ops) =>
    if values.size() != ops.size()
        runtime.error('count(matrix<bool> id, array<bool> values, array<string> ops): ' + 
          '`values` and `ops` must be the same size!')

    map<bool, int> countMap = map.new<bool, int>()

    for row = 0 to id.rows() - 1
        for col = 0 to id.columns() - 1
            bool element = id.get(row, col)

            for [i, value] in values
                if countMap.keys().includes(value)
                    int count = countMap.get(value)
                    string op = ops.get(i)
    
                    if comparisonCheck(element, op, value)
                        count += 1
    
                    countMap.put(value, count)
                else
                    countMap.put(value, 1)

    countMap
// }



//#endregion Elements Matrix Count