Would it be possible for you to manually list the entries for a 4 by 4 example? Perhaps something like

1,1, function or expression to use for this entry
1,2, function or expression to use for this entry
...
4,3, function or expression to use for this entry
4,4, function or expression to use for this entry

If you could do that and the pattern of what you really wanted to accomplish would be clear to someone after reading this then someone might be able to come up with a few lines of code that would do it.

If you aren't really certain that someone else who knows almost nothing about what is in your head will be able to read that list and be able to give you the right answer on the first try then maybe you could think of another way you could write down a set of directions on a piece of paper, hand it to someone who knows nothing about anything except how to follow directions, they would take that sheet of paper and come back in an hour with exactly what it is that you need done.

Without having something more concrete to work with people are groping and trying to figure out how to correctly "do some stuff with some stuff."

I should have spelt out explicitly that using Table is not suitable for computing recursive relations because when computing the ith element of the array, it is not possible to refer back to the i-1th element.

If you decide to use arrays (they're called lists in Mathematica) to do this computation, then Do might be a little easier than While. First the array would need to be pre-allocated, as in

arr = ConstantArray[0, {10, 10}];

Then fill it up as

Do[arr[[i, j]] = ... , {i,1,10}, {j,1,10}]

Notice that arrays are indexed using [[...]], not [...].

However, what I showed you with the Fibonacci example is probably more suitable for this type of calculation than arrays. In the end it will easier to manage, but it does have a learning curve.

You also asked about returning 0 for all negative indices. This is not possible with arrays, but it is possible with functions.

The Fibonacci example would be extended by adding this:

fib[n_ /; n < 0] = 0

or alternatively

fib[n_?Negative] = 0

In Mathematica a function can have multiple definitions for multiple argument patterns (e.g. fib was defined separately for the input 0, 1, negative inputs, or arbitrary inputs). So issuing an additional definition doesn't clear the previous one. This is why it's necessary to use Clear before redefining a function.

To compute a recursive relation, the easiest way is to define a function recursively. The example which is usually given is Fibonacci:

First clear the function definition and any cached values:

Clear[fib]

These are needed to stop the recursion and avoid an infinite loop:

fib[0] = 0
fib[1] = 1

The recursion, with caching:

fib[n_] := (fib[n] = fib[n-1] + fib[n-2])

Now try fib[10] then check the definition of fib using ?fib and see how values got cached.

Notice that this implementation uses = to cache every result, thus avoiding the exponential complexity that would result from the double recursion. This technique is called memoization and you'll find a lot of information about it by googling.

Here's a two-variable example:

Clear[f]    
f[0, j_] = 1
f[i_, 0] = 1
f[i_, j_] := f[i, j] = f[i - 1, j] + f[i, j - 1]

Doing this requires some familiarity with Mathematica, and if you're a beginner, I recommend going through at least a few tutorials first:

• http://reference.wolfram.com/language/tutorial/EverythingIsAnExpression.html
• http://reference.wolfram.com/language/tutorial/DefiningFunctions.html
• http://reference.wolfram.com/language/tutorial/ImmediateAndDelayedDefinitions.html
• http://reference.wolfram.com/language/tutorial/FunctionsThatRememberValuesTheyHaveFound.html

There's also RSolve for solving recursion relations symbolically.

It looks like this is a standard application for Table. Please look up Table in the documentation. There are many examples.

For example,

g = Table[10 i+j, {i, 10}, {j, 10}]

Try to avoid a programming style where array elements are explicitly set in a loop. Often there are easier and simpler solutions in Mathematica.

To make it easier to understand the question, can you post some pseudo-code that describes the algorithm you're trying to implement?

Can you explain why Table is not suitable for what you are trying to do?