applied.ps1

[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Scope = 'Function', Target = 'Get-Extremum')]
[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Scope = 'Function', Target = 'Get-LogisticSigmoid')]
[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Scope = 'Function', Target = 'Get-Mean')]
[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Scope = 'Function', Target = 'Get-Permutation')]
[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Scope = 'Function', Target = 'Get-Sum')]
[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSReviewUnusedParameter', '', Scope = 'Function', Target = 'Invoke-Imputation')]
[Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseDeclaredVarsMoreThanAssignments', '', Scope = 'Function', Target = 'Find-LargestMoveable')]
Param()

function ConvertTo-Degree {
    <#
    .SYNOPSIS
    Convert radians to degrees
    #>
    [CmdletBinding()]
    [Alias('toDegree')]
    [OutputType([Double])]
    Param(
        [Parameter(Mandatory = $True, Position = 0, ValueFromPipeline = $True)]
        [Double] $Radians
    )
    Process {
        ($Radians * (180 / [Math]::Pi)) % 360
    }
}
function ConvertTo-Radian {
    <#
    .SYNOPSIS
    Convert degrees to radians
    #>
    [CmdletBinding()]
    [Alias('toRadian')]
    [OutputType([Double])]
    Param(
        [Parameter(Mandatory = $True, Position = 0, ValueFromPipeline = $True)]
        [Double] $Degrees
    )
    Process {
        ($Degrees % 360) * ([Math]::Pi / 180)
    }
}
function Get-Covariance {
    <#
    .SYNOPSIS
    Return covariance of two discrete uniform random variables
    .DESCRIPTION
    Covariance measures the total variation of two random variables from their expected values.
    Using covariance, we can only gauge the direction of the relationship (whether the variables tend to move in tandem or show an inverse relationship).
    However, it does not indicate the strength of the relationship, nor the dependency between the variables.
    To measure the strength and relationship between variables, calculate correlation.
    .PARAMETER Sample
    Divide by ($Data.Count - 1) instead of $Data.Count. Reasearch "degrees of freedom" for more information. May also be referred to as "unbiased".
    .EXAMPLE
    $X = 1692,1978,1884,2151,2519
    $Y = 68,102,110,112,154
    $X,$Y | Get-Covariance -Sample
    #>
    [CmdletBinding()]
    [Alias('covariance')]
    Param(
        [Parameter(Position = 0, ValueFromPipeline = $True)]
        [Array] $Data,
        [Switch] $Sample
    )
    End {
        $Values = if ($Input.Count -eq 2) { $Input } else { $Data }
        $X, $Y = $Values
        $MeanX = Get-Mean $X
        $MeanY = Get-Mean $Y
        $ResidualX = $X | ForEach-Object { $_ - $MeanX }
        $ResidualY = $Y | ForEach-Object { $_ - $MeanY }
        $Values = $ResidualX, $ResidualY | Invoke-Zip | ForEach-Object { $_[0] * $_[1] }
        if ($Sample) {
            ($Values | Get-Sum) / ($Values.Count - 1)
        } else {
            Get-Mean $Values
        }
    }
}
function Get-Extremum {
    <#
    .SYNOPSIS
    Function to return extremum (maximum or minimum) of an array of numbers
    .EXAMPLE
    $Maximum = 1,2,3,4,5 | Get-Extremum -Max
    # 5
    .EXAMPLE
    $Minimum = 1,2,3,4,5 | Get-Extremum -Min
    # 1
    #>
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory = $True, Position = 0, ValueFromPipeline = $True)]
        [Array] $InputObject,
        [Alias('Max')]
        [Switch] $Maximum,
        [Alias('Min')]
        [Switch] $Minimum
    )
    Begin {
        function Invoke-GetExtremum {
            Param(
                [Parameter(Position = 0)]
                [Array] $Values
            )
            if ($Values.Count -gt 0) {
                if ($Values[0] | Test-Match -Date) {
                    $Sorted = $Values | Sort-Object { [System.DateTime]::Parse($_) }
                    $Parameters = if ($Minimum) {
                        @{ First = 1 }
                    } else {
                        @{ Last = 1 }
                    }
                    $Sorted | Select-Object @Parameters
                } else {
                    $Type = if ($Maximum) { 'Maximum' } else { 'Minimum' }
                    $Parameters = @{
                        Maximum = $Maximum
                        Minimum = $Minimum
                    }
                    $Values | Measure-Object @Parameters | ForEach-Object { $_.$Type }
                }
            }
        }
        Invoke-GetExtremum $InputObject
    }
    End {
        Invoke-GetExtremum $Input
    }
}
function Get-Factorial {
    <#
    .SYNOPSIS
    Return factorial of Value, Value!
    .EXAMPLE
    Get-Factorial 10
    # 3628800
    .EXAMPLE
    200 | factorial
    # 788657867364790503552363213932185062295135977687173263294742533244359449963403342920304284011984623904177212138919638830257642790242637105061926624952829931113462857270763317237396988943922445621451664240254033291864131227428294853277524242407573903240321257405579568660226031904170324062351700858796178922222789623703897374720000000000000000000000000000000000000000000000000
    #>
    [CmdletBinding()]
    [OutputType([Int])]
    Param(
        [Parameter(Position = 0, ValueFromPipeline = $True)]
        [Int] $Value
    )
    Process {
        if ($Value -eq 0) {
            1
        } else {
            1..$Value | Invoke-Reduce {
                Param(
                    [BigInt] $Acc,
                    [BigInt] $Item
                )
                [BigInt]::Multiply($Acc, $Item)
            }
        }
    }
}
function Get-LogisticSigmoid {
    <#
    .SYNOPSIS
    For a given value, x, returns value of logistic sigmoid function at x
    Note: Available as static method of Prelude class - [Prelude]::Sigmoid
    .DESCRIPTION
    The logistic sigmoid function is commonly used as an activation function within neural networks and to model population growth.
    .PARAMETER Midpoint
    Abscissa axis coordinate of logistic sigmoid function reflection point
    .PARAMETER MaximumValue
    Logistic sigmoid function maximum value
    .PARAMETER Derivative
    Switch parameter to determine which function to use, f(x) or f'(x) = f(x) * f(-x)
    #>
    [CmdletBinding()]
    [Alias('sigmoid')]
    [OutputType([Double])]
    Param(
        [Parameter(Mandatory = $True, Position = 0, ValueFromPipeline = $True)]
        [Alias('x')]
        [Double] $Value,
        [Alias('k')]
        [Double] $GrowthRate = 1,
        [Alias('x0')]
        [Double] $Midpoint = 0,
        [Alias('L')]
        [Double] $MaximumValue = 1,
        [Switch] $Derivative
    )
    Process {
        $Sigmoid = { Param($X) $MaximumValue / (1 + [Math]::Pow([Math]::E, (-1 * $GrowthRate) * ($X - $Midpoint))) }
        $Result = & $Sigmoid $Value
        if ($Derivative) {
            $Result * (1 - $Result)
        } else {
            $Result
        }
    }
}
function Get-Maximum {
    <#
    .SYNOPSIS
    Wrapper for Get-Extremum with the -Maximum switch
    #>
    [CmdletBinding()]
    [Alias('max')]
    Param(
        [Parameter(Mandatory = $True, Position = 0, ValueFromPipeline = $True)]
        [Array] $Values
    )
    Begin {
        if ($Values.Count -gt 0) {
            $Values | Get-Extremum -Maximum
        }
    }
    End {
        if ($Input.Count -gt 0) {
            $Input | Get-Extremum -Maximum
        }
    }
}
function Get-Mean {
    <#
    .SYNOPSIS
    Calculate mean (average) for list of numerical values
    .DESCRIPTION
    Specifically, this function returns the "expected value" (mean) for a discrete uniform random variable.
    .PARAMETER Trim
    Return "trimmed" mean where a certain number of items from the beginning and end of the sorted data are excluded from the mean.
    Note: If this parameter value is in the range (0,1), it will be treated as a percentage.
    .EXAMPLE
    1..10 | mean
    .EXAMPLE
    1..10 | mean -Trim 1
    .EXAMPLE
    1..10 | mean -Quadratic
    #>
    [CmdletBinding()]
    [Alias('mean')]
    [OutputType([System.Double])]
    Param(
        [Parameter(Mandatory = $True, Position = 0, ValueFromPipeline = $True)]
        [Array] $Data,
        [Switch] $Arithmetic,
        [Switch] $Geometric,
        [Switch] $Harmonic,
        [Alias('RMS')]
        [Switch] $Quadratic,
        [ValidateRange(0, [Double]::PositiveInfinity)]
        [Double] $Trim = 0,
        [Array] $Weight
    )
    End {
        if ($Input.Count -gt 0) {
            $Data = $Input
        }
        if ($Trim -gt 0 -and $Trim -lt 1) {
            $Trim = [Math]::Floor($Trim * $Data.Count)
        }
        $Type = Find-FirstTrueVariable 'Arithmetic', 'Geometric', 'Harmonic', 'Quadratic'
        $Data = $Data | Sort-Object
        $Data = $Data[$Trim..($Data.Count - 1 - $Trim)]
        switch ($Type) {
            'Arithmetic' {
                ($Data | Get-Sum -Weight $Weight) / $Data.Count
            }
            'Geometric' {
                $Product = $Data | Invoke-Reduce -Multiply
                [Double]([Math]::Pow($Product, 1 / $Data.Count))
            }
            'Harmonic' {
                if ($Weight) {
                    '==> Harmonic mean does not use weights' | Write-Warning
                }
                $Sum = $Data | ForEach-Object { 1 / $_ } | Get-Sum
                $Data.Count / $Sum
            }
            'Quadratic' {
                if ($Weight) {
                    '==> Quadratic mean does not use weights' | Write-Warning
                }
                $Sum = $Data | ForEach-Object { [Math]::Pow($_, 2) } | Get-Sum
                [Math]::Sqrt($Sum / $Data.Count)
            }
        }
    }
}
function Get-Median {
    <#
    .SYNOPSIS
    Calculate median for list of numerical values
    .DESCRIPTION
    Specifically, this function returns the median for a discrete uniform random variable.
    .EXAMPLE
    1..10 | median
    #>
    [CmdletBinding()]
    [Alias('median')]
    Param(
        [Parameter(Mandatory = $True, Position = 0, ValueFromPipeline = $True)]
        [Array] $Data
    )
    End {
        if ($Input.Count -gt 0) {
            $Data = $Input
        }
        $Sorted = $Data | Sort-Object
        $Index = $Sorted.Count / 2
        if ($Sorted.Count % 2 -eq 0) {
            $Left = $Sorted[$Index - 1]
            $Right = $Sorted[$Index]
        } else {
            $Left = [Math]::Floor($Sorted[$Index])
            $Right = $Left
        }
        ($Left + $Right) / 2
    }
}
function Get-Minimum {
    <#
    .SYNOPSIS
    Wrapper for Get-Extremum with the -Minimum switch
    #>
    [CmdletBinding()]
    [Alias('min')]
    Param(
        [Parameter(Mandatory = $True, Position = 0, ValueFromPipeline = $True)]
        [Array] $Values
    )
    Begin {
        if ($Values.Count -gt 0) {
            $Values | Get-Extremum -Minimum
        }
    }
    End {
        if ($Input.Count -gt 0) {
            $Input | Get-Extremum -Minimum
        }
    }
}
function Get-Permutation {
    <#
    .SYNOPSIS
    Return permutaions of input object
    .DESCRIPTION
    Implements the "Steinhaus–Johnson–Trotter" algorithm that leverages adjacent transpositions ("swapping")
    combined with lexicographic ordering in order to create a list of permutations.
    In mathematical terms, the number of items return by Get-Permutation can be quantified as follows:
        Get-Permutation $n ==> (Get-Factorial $n) items = P(n,n) = n!
        Get-Permutation $n -Choose $k ==> ((Get-Factorial $n) / (Get-Factorial ($n - $k))) items = P(n,k) = n! / (n - k)!
        Get-Permutation $n -Choose $k -Unique ==> ((Get-Factorial $n) / ((Get-Factorial $k) * (Get-Factorial ($n - $k)))) items = C(n,k) = n! / k!(n - k)!
    Note: Get-Permutation will start to exhibit noticeable pause before completion for n = 7
    .PARAMETER Words
    Combine individual permutations as strings (see examples)
    .PARAMETER Choose
    Return permutations selected from -Choose items. For a value of "k" for Choose parameter,
    the equivalent mathematical formula for the number items returned by "Get-Permutation n -Choose k" is: n! / (n - k)!
    .PARAMETER Unique
    Return only permutations that are unique up to set membership (order does not matter)
    .EXAMPLE
    2 | Get-Permutation
    # @(0,1),@(1,0)

    1,2 | Get-Permutation
    # @(1,2),@(2,1)

    2 | Get-Permutation -Offset 1
    # @(1,2).@(2,1)
    .EXAMPLE
    'cat' | permute -Words
    # 'cat','cta','tca','tac','atc','act'
    .EXAMPLE
    'hello' | permute -Choose 2 -Unique -Words
    # 'he','hl','hl','ho','el','el','eo','ll','lo','lo'
    #>
    [CmdletBinding()]
    [Alias('permute')]
    Param(
        [Parameter(Position = 0, ValueFromPipeline = $True)]
        [Array] $InputObject,
        [Parameter(Position = 1)]
        [Int] $Offset = 0,
        [Int] $Choose,
        [Switch] $Unique,
        [Switch] $Words
    )
    Begin {
        function Invoke-Swap {
            <#
            .SYNOPSIS
            Swap two elements of an array
            .DESCRIPTION
            Uses the algorithm, b = (a += b -= a) - b
            #>
            Param(
                [Array] $Items,
                [Int] $Next,
                [Int] $Current
            )
            $Items[$Next] = ($Items[$Current] += $Items[$Next] -= $Items[$Current]) - $Items[$Next]
        }
        function Test-Moveable {
            Param(
                [Parameter(Position = 0)]
                [Array] $Work,
                [Parameter(Position = 1)]
                [Array] $Direction,
                [Parameter(Position = 2)]
                [Int] $Index
            )
            if (($Index -eq 0 -and $Direction[$Index] -eq 0) -or ($Index -eq ($Work.Count - 1) -and $Direction[$Index] -eq 1)) {
                return $False
            }
            if (($Index -gt 0) -and ($Direction[$Index] -eq 0) -and ($Work[$Index] -gt $Work[$Index - 1])) {
                return $True
            }
            if ($Index -lt ($Work.Count - 1) -and ($Direction[$Index] -eq 1) -and ($Work[$Index] -gt $Work[$Index + 1])) {
                return $True
            }
            if (($Index -gt 0) -and ($Index -lt $Work.Count)) {
                if (($Direction[$Index] -eq 0 -and $Work[$Index] -gt $Work[$Index - 1]) -or ($Direction[$Index] -eq 1 -and $Work[$Index] -gt $Work[$Index + 1])) {
                    return $True
                }
            }
            return $False
        }
        function Test-MoveableExist {
            [OutputType([Bool])]
            Param(
                [Parameter(Position = 0)]
                [Array] $Work,
                [Parameter(Position = 1)]
                [Array] $Direction
            )
            $IsMoveable = $False
            for ($Index = 0; $Index -lt $Work.Count; $Index++) {
                if (Test-Moveable -Work $Work -Direction $Direction -Index $Index) {
                    $IsMoveable = $True
                    break
                }
            }
            $IsMoveable
        }
        function Find-LargestMoveable {
            Param(
                [Parameter(Position = 0)]
                [Array] $Work,
                [Parameter(Position = 1)]
                [Array] $Direction
            )
            $Index = 0
            foreach ($Item in $Work) {
                if ((Test-Moveable -Work $Work -Direction $Direction -Index $Index) -and ($Largest -lt $Item)) {
                    $Largest = $Item
                    $Position = $Index
                }
                $Index++
            }
            $Position
        }
        function Invoke-Permutation {
            Param(
                [Parameter(Position = 0)]
                [Int] $Value,
                [Parameter(Position = 1)]
                [Int] $Offset,
                [Int] $Choose,
                [Switch] $Unique
            )
            $Results = New-Object 'Object[]' @((Get-Factorial $Value))
            $Work = 0..($Value - 1) | ForEach-Object { $_ + $Offset }
            $Direction = $Work | ForEach-Object { 0 }
            $Step = 1
            $Results[0] = $Work.Clone()
            while ((Test-MoveableExist $Work $Direction)) {
                $Current = Find-LargestMoveable $Work $Direction
                $NextPosition = if ($Direction[$Current] -eq 0) { $Current - 1 } else { $Current + 1 }
                Invoke-Swap -Items $Work -Next $NextPosition -Current $Current
                Invoke-Swap -Items $Direction -Next $NextPosition -Current $Current
                0..($Value - 1) |
                    Where-Object { $Work[$_] -gt $Work[$NextPosition] } |
                    ForEach-Object { $Direction[$_] = if ($Direction[$_] -eq 0) { 1 } else { 0 } }
                $Results[$Step] = $Work.Clone()
                $Step++
            }
            if ($Choose -gt 0) {
                $Items = New-Object 'System.Collections.ArrayList'
                foreach ($Result in $Results) {
                    [Void]$Items.Add($Result[0..($Choose - 1)])
                }
                $Results = $Items | Select-Object -Unique
            }
            if ($Unique) {
                $Choices = New-Object 'System.Collections.ArrayList'
                foreach ($Result in $Results) {
                    $Choice = $Result | Sort-Object
                    [Void]$Choices.Add($Choice)
                }
                $Choices | Sort-Object -Unique
            } else {
                $Results
            }
        }
        $GetResults = {
            Param(
                [Parameter(Position = 0)]
                [Array] $InputObject
            )
            $Count = $InputObject.Count
            $Items = $InputObject
            $Value = $Count
            if ($Count -gt 0) {
                if ($Count -eq 1) {
                    $First = $InputObject[0]
                    $Type = $First.GetType().Name
                    if ($Null -ne $First -and $Type -eq 'String') {
                        $Items = $First.ToCharArray()
                        $Value = $Items.Count
                    } elseif ($Type -match 'Int') {
                        $Items = @()
                        $Value = $First
                    }
                }
                if ($Items.Count -gt 0) {
                    $Result = [System.Collections.ArrayList]@{}
                    $Parameters = @{
                        Value = $Value
                        Offset = 0
                        Choose = $Choose
                        Unique = $Unique
                    }
                    foreach ($Item in (Invoke-Permutation @Parameters)) {
                        $Permutation = $Items[$Item]
                        if ($Words) {
                            $Permutation = $Permutation -join ''
                        }
                        [Void]$Result.Add($Permutation)
                    }
                    $Result
                } else {
                    $Parameters = @{
                        Value = $Value
                        Offset = $Offset
                        Choose = $Choose
                        Unique = $Unique
                    }
                    Invoke-Permutation @Parameters | Sort-Object -Property { $_ -join '' }
                }
            }
        }
        & $GetResults $InputObject
    }
    End {
        & $GetResults $Input
    }
}
function Get-Softmax {
    <#
    .SYNOPSIS
    Apply "softmax" function to list of numbers
    .EXAMPLE
    1..10 | Get-Softmax
    .EXAMPLE
    Get-Softmax 1..10
    #>
    [CmdletBinding()]
    [Alias('softmax')]
    [OutputType([Int[]])]
    [OutputType([Matrix])]
    Param(
        [Parameter(Position = 0, ValueFromPipeline = $True)]
        [Array] $Values
    )
    Begin {
        function Get-Softmax_ {
            Param($Values)
            $Numerators = $Values | ForEach-Object { [Math]::Exp($_) }
            $Denominator = $Numerators | Get-Sum
            foreach ($Value in $Numerators) {
                $Value / $Denominator
            }
        }
        if ($Values.Count -gt 0) {
            if ($Values[0].GetType().Name -eq 'Matrix') {
                $Size = $Values.Size
                Get-Softmax_ -Values $Values.Values.Real | New-Matrix $Size
            } else {
                Get-Softmax_ -Values $Values
            }
        }
    }
    End {
        if ($Input.Count -gt 0) {
            if ($Input[0].GetType().Name -eq 'Matrix') {
                $Size = $Input.Size
                Get-Softmax_ -Values $Input.Values.Real | New-Matrix $Size
            } else {
                Get-Softmax_ -Values $Input
            }
        }
    }
}
function Get-Sum {
    <#
    .SYNOPSIS
    Calculate sum of list of numbers or count number of true values within a list
    .EXAMPLE
    1..100 | sum
    # 5050
    .EXAMPLE
    $True, $False, $False, $False, $True | Get-Sum
    # 2
    #>
    [CmdletBinding()]
    [Alias('sum')]
    [OutputType([System.Numerics.Complex])]
    [OutputType([Int])]
    Param(
        [Parameter(Position = 0, ValueFromPipeline = $True)]
        [Array] $Values,
        [Parameter(Position = 1)]
        [Array] $Weight
    )
    Begin {
        function Get-Sum_ {
            Param($Values)
            if ($Values.Count -gt 0) {
                switch ($Values[0].GetType().Name) {
                    'Boolean' {
                        ($Values | Where-Object { $_ }).Count
                    }
                    default {
                        if ($Weight.Count -eq $Values.Count) {
                            $Size = $Values.Count
                            $X = $Values | New-Matrix -Size 1, $Size
                            $W = $Weight | New-Matrix -Size $Size, $Size -Diagonal
                            $Values = ($X * $W).Values
                        }
                        $Sum = 0
                        foreach ($Value in $Values) {
                            $Sum += $Value
                        }
                        if ($Sum.Imaginary -eq 0) {
                            $Sum.Real
                        } else {
                            $Sum
                        }
                    }
                }
            }
        }
        Get-Sum_ $Values
    }
    End {
        Get-Sum_ $Input
    }
}
function Get-Variance {
    <#
    .SYNOPSIS
    Return variance for discrete uniform random variable
    .DESCRIPTION
    The variance is basically the spread (dispersion) of the data.
    .PARAMETER Sample
    Divide by ($Data.Count - 1) instead of $Data.Count. Reasearch "degrees of freedom" for more information. May also be referred to as "unbiased".
    .EXAMPLE
    1..10 | Get-Variance
    .EXAMPLE
    1..10 | variance -Sample
    #>
    [CmdletBinding()]
    [Alias('variance')]
    Param(
        [Parameter(Position = 0, ValueFromPipeline = $True)]
        [Array] $Data,
        [Switch] $Sample
    )
    End {
        $Values = if ($Input.Count -gt 0) { $Input } else { $Data }
        if ($Sample -and $Values.Count -gt 1) {
            $Mean = Get-Mean $Values
            $SquaredResidual = $Values | ForEach-Object { [Math]::Pow(($_ - $Mean), 2) }
            ($SquaredResidual | Get-Sum) / ($Values.Count - 1)
        } else {
            $Squared = $Values | ForEach-Object { [Math]::Pow($_, 2) }
            (Get-Mean $Squared) - [Math]::Pow((Get-Mean $Values), 2)
        }
    }
}
function Invoke-Imputation {
    <#
    .SYNOPSIS
    Impute missing values in a data set.
    .DESCRIPTION
    Performs "unit imputation" on set of values, replacing $Null or empty string values with a substitue value, -With.
    .PARAMETER With
    Value to replace null and empty values With
    .PARAMETER Limit
    Limit the number of values to be imputed
    .EXAMPLE
    1, $Null, 3, $Null, 5 | Invoke-Imputation -With 42
    # 1, 42, 3, 42, 5
    .EXAMPLE
    1, $Null, 3, $Null, 5 | Invoke-Imputation -With 42 -Limit 1
    # 1, 42, 3, $Null, 5
    #>
    [CmdletBinding()]
    [Alias('impute')]
    Param(
        [Parameter(Mandatory = $True, Position = 0, ValueFromPipeline = $True)]
        [AllowNull()]
        [Array] $Values,
        [Parameter(Position = 1)]
        [Alias('Substitute')]
        $With = 0,
        [Int] $Limit
    )
    Begin {
        function Invoke-Impute {
            Param(
                [Parameter(Position = 0)]
                [AllowNull()]
                [Array] $Values
            )
            if ($Values.Count -gt 0) {
                $Result = @()
                $Count = 0
                foreach ($Value in $Values) {
                    $WithinLimit = (($Limit -gt 0) -and ($Count -lt $Limit)) -or ($Limit -eq 0)
                    if ($WithinLimit -and [String]::IsNullOrEmpty($Value)) {
                        $Result += $With
                        $Count += 1
                    } else {
                        $Result += $Value
                    }
                }
                $Result
            }
        }
        Invoke-Impute $Values
    }
    End {
        Invoke-Impute $Input
    }
}