Climbing binomial tree to find the option value Background:

In finance, the binomial options pricing model (BOPM) is the simplest technique used for option pricing. The mathematics behind the model is relatively easy to understand and (at least in their basic form) it is not difficult to implement. This model was first proposed by Cox, Ross, and Rubinstein in 1979. Quoting Wikipedia:


  The binomial pricing model traces the evolution of the option's key underlying variables in discrete-time. This is done by means of a binomial lattice (tree), for a number of time steps between the valuation and expiration dates. Each node in the lattice represents a possible price of the underlying at a given point in time.
  
  Valuation is performed iteratively, starting at each of the final nodes (those that may be reached at the time of expiration), and then working backwards through the tree towards the first node (valuation date). The value computed at each stage is the value of the option at that point in time.


For this challenge's sake, we will create a simple model to predict potential future prices of the option(s) by creating a lattice or a tree as shown below (a picture is worth a thousand words):



where S is the option price today, p is the probability of a price rise, and t is the period of time or number of steps.

Challenge:

The challenge is to write either a program or a function which take S, p (in percent), and t as the inputs and give the binomial tree as the output. The output of the program or the function must follow the format above, but the boxes and the arrow lines are optional. For example, if the program take inputs S = 100, p = 10%, and t = 3, then its output may be in the following simple form:

                        133.1
                121 
        110             108.9
100              99 
         90              89.1
                 81 
                         72.9


General rules:


This is code-golf, so the shortest answer in bytes wins the challenge.
Don't let esolangs discourage you from posting an answer with regular languages. Enjoy this challenge by providing an answer as short as possible with your programming language. If you post a clever answer and a clear explanation, your answer will be appreciated (hence the upvotes) regardless of the programming language you use.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/ method with the proper parameters, full programs, etc. The choice is yours.
Using a binomial tree built-in is forbidden.
If possible, your program can properly handle a large number of steps. If not, that will just be fine.


References:


Binomial options pricing model
Binomial tree option calculator
Python, 168 167 bytes

q=lambda s,p,t:'\n'.join(''.join('%e'%(s*(1+p)**(c-(r+c-t)//2)*(1-p)**((r+c-t)//2))if(t-c&lt;=r&lt;=t+c)&amp;(r%2^(c+~t%2)%2)else' '*12for c in range(t+1))for r in range(2*t+1))

Test case with anonymous function above assigned to f would be print(f(100,0.1,3)), yielding:
                                    1.331000e+02
                        1.210000e+02
            1.100000e+02            1.089000e+02
1.000000e+02            9.900000e+01
            9.000000e+01            8.910000e+01
                        8.100000e+01
                                    7.290000e+01

Extending the same to t=4 would be print(f(100,0.1,3)), yielding:
                                                1.464100e+02
                                    1.331000e+02
                        1.210000e+02            1.197900e+02
            1.100000e+02            1.089000e+02
1.000000e+02            9.900000e+01            9.801000e+01
            9.000000e+01            8.910000e+01
                        8.100000e+01            8.019000e+01
                                    7.290000e+01
                                                6.561000e+01


For the avoidance of scientific notation while keeping at least 3 significant figures we can use the following 211 byte code instead:
lambda s,p,t:'\n'.join(''.join('%12s'%(v and(10**5&gt;v&gt;.0001and'%f'%v or'%e'%v)or'')for v in[(t-c&lt;=r&lt;=t+c)&amp;(r%2^(c+~t%2)%2)and s*(1+p)**(c-(r+c-t)//2)*(1-p)**((r+c-t)//2)for c in range(t+1)])for r in range(2*t+1))

Test case, print(f(100,0.1,3)) yields:
                                      133.100000
                          121.000000
              110.000000              108.900000
  100.000000               99.000000
               90.000000               89.100000
                           81.000000
                                       72.900000

then when numbers get too big or small, for example print(f(9876.000123,0.99,6)):
                                                                        6.133375e+05
                                                            3.082098e+05
                                                1.548793e+05             3082.098178
                                    77828.796693             1548.793054
                        39109.948087              778.287967               15.487931
            19653.240245              391.099481                7.782880
 9876.000123              196.532402                3.910995                0.077829
               98.760001                1.965324                0.039110
                            0.987600                0.019653                0.000391
                                        0.009876                0.000197
                                                9.876000e-05            1.965324e-06
                                                            9.876000e-07
                                                                        9.876000e-09