Factorial (recursive function)

(defun factorial (n)                                
  (if (= n 0)                                       
    1                                             
    (if (> n 0)                                   
      (* n (factorial (- n 1))))))

It is worthwhile to remark that a product is no sooner created than it, from that instant, affords a market for other products to the full extent of its own value. When the producer has put the finishing hand to his product, he is most anxious to sell it immediately, lest its value should diminish in his hands. Nor is he less anxious to dispose of the money he may get for it; for the value of money is also perishable. But the only way of getting rid of money is in the purchase of some product or other. Thus the mere circumstance of creation of one product immediately opens a vent for other products. (J.B. Say, 1803: p.138-9)

In other words:

• Products create a market for themselves
• They do this because producers are eager to exchange their products for their maximum value
• The value of products degrades over time, so the producer is eager to exchange as soon as possible
• The value of money degrades over time as well, so the producer is eager to exchange again for more product
• Since the value of money is arbitrary and tied to the production and exchange of products, the products create a market for themselves

This seems like it would hold in high-competition industries where the costs of learning about competing products are low (easy to shop around). Money is a powerful symbol, and in this interpretation the money stands for products. The relative rates of production determine the prices of products– implicitly creating demand.

Say’s law is a highly simplified view, according to modern detractors like Keynes. Some of the more convincing critiques I found against the law were:

• If prices don’t move freely up and down, then money becomes disengaged from the value of the product.
• Government intervention can create skewed supply. This can be through subsidies, taxation, pricing laws, etc.
• Speculation and investment in non-capital goods provide other places to “dispose of the money” besides acquiring a new, degradable product

That last point is a bit confusing– but consider the purchase of one media company by a conglomerate. The conglomerate is not investing strictly in the cameras, distribution capabilities, etc– it’s also investing in the talent, brand and audience the media company reaches (or has the potential to reach). These are intangibles which may or may not pay off– but they’re not a product in the sense that Say’s was talking about.

On the other hand, there are farmer’s markets, which operate a lot like Say’s law. In the morning the place is bustling, with the best products on the tables and money quickly changing hands. People look to diversify their diets, and they consider trade-offs of all the products in the market. I’m even eager to get rid of my money, as Say predicts, since I know the market has some of the best deals around. As the day goes on, the crowd wanes and sellers drop their prices unloading the rest of their goods. And money’s actually working like it should!

Hidden layer neurons are large groups of neurons between an input layer and output layer– your sensory receptors and your motor actions. Their size, type, and network topology (who connects to who) affect the complexity of problems they solve and decisions they make. Successful networks find solutions because they are statistically favored. Neurons compete for resources. With successful predictions, they grow stronger. Those that fail to make patterns out of chaos weaken. These cells even contain programming to destroy themselves, a process called apoptosis. This occurs at a rapid rate early in life as the brain first organizes itself, then slows down in adulthood.

We seem to be able to direct our own mental processes, somehow– which is absurd to me. One part of the brain exerting control of another? Different patterns resonating in electrochemical waves: metastable yet amplifying. Consciousness subsuming itself with each passing moment. Alive. It seems awfully political: these neurons in such chaotic, demanding labor to produce a transient mind. They are decision-making agents: competing for scarce resources, struggling for strong connections, forming computational alliances. The competition for statistical significance may be experienced as a tug of attention, a drive to act, or a flash of inspiration. The steps neurons take to assemble personal truth are invisible.

Here’s the jQuery, hover.js:

$(function() {
    var navButtons = '#home, #cast, #pictures, #videos, #mail';
    $(navButtons).hover(function() {
        $(this).stop().animate({'top':'-30px'});
        }, function () {
        $(this).stop().animate({'top':'0px'})
        });
});

style.css, color scheme “Sunrise over Myanmar” by pixelperfectt on Kuler.

#nav_bar {
    float:top;
    margin:0px auto;
    padding:0;
    position:relative;
    text-align:center;
    width:500px;
    height:30px;
    overflow:hidden;
}
#home, #cast, #pictures, #videos, #mail {
    float:left;
    width:70px;
    height:60px;
    line-height:15px;
    font-size:10px;
    font-family:sans-serif;
    color:#ffffff;
    font-weight:bold;
    border:0px solid white;
    position:relative;
}
#nav_bar h2 {
    line-height:30px;
    font-size:15px;
    margin:0px;
    padding:0px;
}
 
.nav_top, .nav_bottom {
    height:30px;
    float:top;
}
#home {
    background:#29131F;
}
#cast {
    background:#522125;
}
#pictures {
    background:#7F2922;
}
#videos{
    background:#C24D23;
}
#mail {
    background:#DB7422;
}

index.html

<!-- Put the following two lines in the <head> section -->
<script src="jquery-1.3.2.min.js" type="text/javascript"></script>
<script src="hover.js" type="text/javascript"></script>
 
<!-- The menu -->
<div id="nav_bar">
  <div id="home">
    <div class="nav_top">
      <h2>home</h2>
    </div>
    <div class="nav_bottom">twitters, dates,and news!</div>
  </div>
  <div id="cast">
    <div class="nav_top">
      <h2>cast</h2>
    </div>
    <div class="nav_bottom">current castand alumni!</div>
  </div>
  <div id="pictures">
    <div class="nav_top">
      <h2>pics</h2>
    </div>
    <div class="nav_bottom">candids andnudes!</div>
    </div>
  <div id="videos">
    <div class="nav_top">
      <h2>vids</h2>
    </div>
    <div class="nav_bottom">la petite teetoriginals!</div>
  </div>
  <div id="mail">
    <div class="nav_top">
      <h2>mail</h2>
    </div>
    <div class="nav_bottom">join ourmailing list!</div>
  </div>
</div>

You’ll also need jquery-1.3.2, though you should try the newest version of jQuery first.

In this tutorial we’ll look at some simple matrix multiplication tools in Python. The arrays are constructed using lists within lists, and the multiplication itself is implemented using for loops. The program works well for small arrays, but really starts bogging down at sizes 500×500 and above. Anyone doing serious work will want to check out NumPy, which has matrix operations built-in and runs several thousand times faster. In Part 2 I’ll compare NumPy’s performance to other optimized methods.

Let’s feast our eyes on the function definitions we’ll be using in matrix.py:

import random
from time import *
import cProfile
 
def zero(m,n):
    # Create zero matrix
    new_matrix = [[0 for row in range(n)] for col in range(m)]
    return new_matrix
 
def rand(m,n):
    # Create random matrix
    new_matrix = [[random.random() for row in range(n)] for col in range(m)]
    return new_matrix
 
def show(matrix):
    # Print out matrix
    for col in matrix:
        print col 
 
def mult(matrix1,matrix2):
    # Matrix multiplication
    if len(matrix1[0]) != len(matrix2):
        # Check matrix dimensions
        print 'Matrices must be m*n and n*p to multiply!'
    else:
        # Multiply if correct dimensions
        new_matrix = zero(len(matrix1),len(matrix2[0]))
        for i in range(len(matrix1)):
            for j in range(len(matrix2[0])):
                for k in range(len(matrix2)):
                    new_matrix[i][j] += matrix1[i][k]*matrix2[k][j]
        return new_matrix
 
def time_mult(matrix1,matrix2):
    # Clock the time matrix multiplication takes
    start = clock()
    new_matrix = mult(matrix1,matrix2)
    end = clock()
    print 'Multiplication took ',end-start,' seconds'
 
def profile_mult(matrix1,matrix2):
    # A more detailed timing with process information
    # Arguments must be strings for this function
    # eg. profile_mult('a','b')
    cProfile.run('matrix.mult(' + matrix1 + ',' + matrix2 + ')')

Load the script into an interactive Python session:

>>> import matrix
>>> a = matrix.zero(1,5)
>>> a
[[0, 0, 0, 0, 0]]
>>> b = matrix.zero(3,5)
>>> b
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
>>> matrix.show(b)        # This function makes arrays more readable.
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]

Try multiplying zero matrices just to check the resulting dimensions:

>>> a = matrix.zero(2,3)
>>> b = matrix.zero(4,5)
>>> c = matrix.mult(a,b)
Matrices must be m*n and n*p to multiply!
>>> b = matrix.zero(3,5)
>>> c = matrix.mult(a,b)
>>> matrix.show(c)        # Note that we end up with an n by p matrix
[0, 0, 0, 0, 0]           # In this case 2x5
[0, 0, 0, 0, 0]

Now do some calculations:

>>> a = [[2,3]]         # 1x2 matrix
>>> b = [[1],[5]]       # 2x1 matrix
>>> c = matrix.mult(a,b)
>>> matrix.show(c)      # [1x2] * [2x1] --> [1x1] matrix
[17]
>>> a = matrix.rand(3,3)
>>> b = matrix.rand(3,3)
>>> c = matrix.mult(a,b)
>>> matrix.show(c)
[1.5756730190235944, 0.70870079587302315, 0.94109431416086442]
[0.48198264627485315, 0.32042216800153944, 0.36885894389577889]
[1.2931982570350344, 0.85088650318922798, 1.1630298461072877]

We can time the multiplication with the last two functions. Try increasing the matrix sizes and see what happens:

>>> a = matrix.rand(3,3)
>>> b = matrix.rand(3,3)
>>> matrix.time_mult(a,b)
Multiplication took  0.0  seconds     # 0.o
>>> a = matrix.rand(300,300)          # Each matrix has 90000 elements now
>>> b = matrix.rand(300,300)
>>> matrix.time_mult(a,b)
Multiplication took  10.35  seconds   # Many more calculations happening
>>> a = matrix.rand(600,600)
>>> b = matrix.rand(600,600)
>>> matrix.time_mult(a,b)
Multiplication took  91.05  seconds   # Not worth going much larger

Take a look at the matrix multiplication loop, mult(matrix1,matrix2). It’s iterating over i, j, and k — each of which is a column or row of a 600×600 matrix. 600^3 = 216 million cycles through Python for loops. That’s O(n^3) complexity, which is quite the pain for large arrays. Take a look at the results of the profiler:

>>> matrix.profile_mult('a','b')
         721811 function calls in 91.598 CPU seconds
 
   Ordered by: standard name
 
   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.005    0.005   91.598   91.598 <string>:1(<module>)
        1   89.996   89.996   91.593   91.593 matrix.py:20(mult)
        1    0.080    0.080    0.088    0.088 matrix.py:5(zero)
   360605    0.049    0.000    0.049    0.000 {len}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
   361202    1.468    0.000    1.468    0.000 {range}