Errors when returning values to the array

When you initialize an array like this: $InputsArr = @(), powershell creates an array of length 0. Thus when you try and address this array with $InputsArr[$innerloop] it throws an error that element $innerloop does not exist.

Two solutions. You can either explicitly initialize an array of a particular type and length:

$InputsArr = New-Object double[] $MaxLoop

Or, you can use the += operator in your code to add new values to an array:

$InputsArr += $InputsArr[$Innerloop - 1] - $ScaleFactor * (2 * $InputsArr[$Innerloop - 1] - 3) #Calculate the second input

+= creates a new array of length n+1, copies the old array, and then adds the new value, so is very inefficient for large arrays. See here.

PowerShell arrays defined by @() are dynamically sized. You can't index-access things in them unless they actually contain elements. That's why you're getting "index out of bounds" exceptions when you use $array[$index] in your for loop. The array simply doesn't have a field $index yet.

Basically there are two ways of filling PowerShell arrays:

• Append to an existing array in a loop:

  $array = @()
  for (...) {
    $array += $foo
  }
  

• Echo the elements inside the loop and assign the loop output to a variable:

  $array = for (...) {
    $foo
  }
  

The former should be avoided for larger numbers of array elements, as each append operation (+=) will create a new array with increased size, copy the elements, then assign the new array to the variable. The latter approach is far superior performance-wise. The only downside of the latter approach is that the result won't be an array unless the loop produces at least two elements. You can mitigate this by enforcing array output: @(for (...) {...}).

PowerShell also allows you to create arrays with fixed size:

$size  = 100
$array = New-Object Object[] $size

However, there's usually no advantage to doing this.

Also note that the first instruction in your loop assumes that the array already contains an initial value:

$InputsArr[$innerloop] = $InputsArr[$Innerloop - 1] - $ScaleFactor * (2 * $InputsArr[$Innerloop - 1] - 3) #Calculate the second input

thus you need to prefill the array with one element before starting the loop:

$InputsArr = @($initialValue)

With that said, there are more PoSh ways of filling an array with values, e.g. like this:

$i = $initialValue
$array = @($i)
$array += 1..$Maxloop | ForEach-Object {
  $i -= $ScaleFactor * (2 * $i - 3)
  $i
}

If you want to fill multiple arrays in the same loop (because you can't use one loop per array for some reason) appending is probably your best option. Like this:

$InputsArr    = @($initialinputs)
$FunctionArr  = @($initialinputs)
$DFunctionArr = @($initialinputs)
for ($i = 1; $i -le $Maxloop -and $DFunctionsArr[-1] -le $Termi; $i++) {
    $InputsArr    += $InputsArr[-1] - $ScaleFactor * (2 * $InputsArr[-1] - 3)
    $FunctionArr  += ([Math]::Pow($InputsArr[-1], 2)) * 2 - 3 * $InputsArr[-1]
    $DFunctionArr += 2 * $InputsArr[-1] - 3
}

or like this, if you don't need $InputsArr later on:

$FunctionArr  = @($initialinputs)
$DFunctionArr = @($initialinputs)
$v = $initialinputs
for ($i = 1; $i -le $Maxloop -and $DFunctionsArr[-1] -le $Termi; $i++) {
    $v -= $ScaleFactor * (2 * $v - 3)

    $FunctionArr  += [Math]::Pow($v, 2) * 2 - 3 * $v
    $DFunctionArr += 2 * $v - 3
}