Trying to return array from function

You could return a (named) Tuple instead of an array.

Basically, declare the function something like this:

Function X(a As Integer) As (RPmt As Decimal, Per As Decimal)
    Dim r = 1.2D
    Dim p = 0.2D

    Return (Rpmt:=r, Per:=p)

End Function

And use it in this fashion:

Dim y = X(1)
Console.WriteLine(y.Per & ", " & y.RPmt)

You can see that the names of the tuple item were used instead of an array index. It makes it much easier to see which item you're meant to be using instead of having to remember which array index each part is in.

Important parts of source code are ease of writing it correctly in the first place and ease of maintenance. Avoiding the use of "magic numbers" contributes to those.

Note that with Option Infer On there is no need to declare the type of y (in the example)—the compiler will figure it out for you.

So you want to return a composite value (a Cartesian product of two decimal values) from your public function/method.

Andrew Morton's answer about using a tuple type instead of an array type for that composite value is a great improvement indeed, since you would be more clear about the specific data structure that you return from your function.

However, because (named) tuples do not do a great job on improving code readability, I personally prefer to limit their definitions to relatively small scopes, in which their usage can be easily overseen. (Like within the private implementation of classes.)

In your scenario - a public function that could be called from anywhere in your code - the returned value could effectively be used anywhere as well. In all those places, the structure of that (named) tuple type has to be specified over and over again. That's not very convenient for the developers (including yourself) who want to call your public function.

So, in scenarios like these, I would do a little more work, so that all client code that invokes your public function will be somewhat more concise and clear: I would define and use a DTO class or structure (named MaxBalInfo for example) instead of a tuple here. Then in all places where your public function is called, the MaxBalInfo type will be used instead of a (named) tuple for processing its return value.

Public Class MaxBalInfo
  Public Property RPmt As Decimal
  Public Property Per As Decimal
End Class

...

Public Function CalcMaxBal(...) As MaxBalInfo
    'this function is only called for a bi-weekly payment computation
    Dim rpmt As Decimal = 255
    Dim per as Decimal = 4

    ...

    Return New MaxBalInfo With
    {
        .RPmt = rpmt
        .Per = per
    }
End Function

By the way, I consider the discussion "class vs structure" (or actually "value type vs reference type") to be off-topic here. My choice for a class (reference type) over a structure (value type) is arbitrary here. But note that when you choose for a tuple type, that you also implicitly choose for a value type. It's up to you to decide if the corresponding difference in behavior will correctly fit into your software design.

You can get return array values using ByRef in Sub.

    Dim result(2) As Decimal
    Public Sub CalcMaxBal(ByRef result() As Decimal, ByVal maxbal As Decimal, ByVal npmts As Int16, ByVal starttype As Int16, ByVal startrate As Decimal, ByVal startper As Int16, ByVal pmtadjcap As Decimal, ByVal pmtadjper As Int16, ByVal origrate As Decimal, ByVal noterate As Decimal, ByVal origbal As Decimal, ByVal totpmts As Int16, ByVal extra As Decimal, ByVal extraper As Int16, ByVal io As Int16, ByVal iocb As Boolean, ByVal miamt As Decimal) 

        'this function is only called for a bi-weekly payment computation
        Dim rpmt As Decimal = 255
        Dim per As Decimal = 4

        result(0) = rpmt
        result(1) = per

    End Sub