• Discussion of numerical stability
  • Binary decimal structure. Is it possible to represent every number exactly?

    >>> a = 3.1
    >>> a
    3.1000000000000001
    >>> a = 35.95
    >>> a
    35.950000000000003

  • IEEE floating point structure
  • Numpy's round allows you to choose the number of decimal places, but how can you floor a decimal to two places?

    a = floor(a * 100.0)/100.0

• In lab problem
  • The plot of Office Space and Superman 3.
    • Write a function named create_accounts that, given input length n, will generate a pseudo-random list of n bank accounts between $0.01 and $10000.00 (inclusive).
    • Write a function named real_interest that, given a list of account balances as input and a percentage of interest p, will calculate the yearly interest, compounded monthly, and update the balance of each account. Note that interest is always rounded to the nearest cent (2 decimal places).
    • Write a function named evil_interest that, given a list of transactions as input and a percentage of interest p, will calculate the yearly interest, and implement the malicious plot as in the movie Office Space, where the interest is always rounded down, and the remainder is dropped into a personal account. The function should return as the amount that you were able to steal with this diabolical plot in one year.
    • Use __main__ and provide a function that will create accounts, and then run the evil interest for 25 years. Use VPython to graph the amount of money you have skimmed into your account, making one plot every year.

from numpy import round, floor
from random import uniform
 
def create_accounts(n):
   accounts = []
   for i in xrange(n):
       accounts.append(round(uniform(0.01, 10000.0), 2))
   return accounts
 
def real_interest(accounts, p):
   for i in xrange(len(accounts)):
       for j in xrange(12):
           accounts[i] += round(accounts[i] * p/12.0, 2)
 
def evil_interest(accounts, p):
   my_account = 0.0
   for i in xrange(len(accounts)):
       for j in xrange(12):
           real_interest = accounts[i] * p/12.0
           interest_floor = floor(real_interest * 100.0)/100.0
           my_share = real_interest - interest_floor
           accounts[i] += interest_floor
           my_account += my_share
   return round(my_account, 2)
 
if __name__ == "__main__":
   from visual import rate, color
   from visual.graph import gdisplay, gcurve
 
   scene = display(                       
     title="How to succeed at business without really trying",
     autocenter=True                     
 
   gdisplay(                               # 2D graph window parameters
     title="Money Illegally Earned",     # Window title
     xtitle="Years",                     # Label on x-axis
     ytitle="Dollars",                   # Label on y-axis
     background=color.white,
     foreground=color.black
   )
 
   green_line = gcurve(color=(0,1,0))       # Set up a green curve
 
   accounts = create_accounts(100000)
   my_account = 0.0
 
   for i in xrange(25):
      my_account += evil_interest(accounts, 0.03)
      print "$", my_account
      green_line.plot(pos=(i, my_account))

• Discuss Part 2 of Project 2: What plots to create and what data to analyze.
  • show the example plot
  • generate the corresponding plots for the other two forms of percolation
  • two setup questions
  • study on impact of grid size is only done for unrestricted percolation
  • mention possible problem with recursion limit
  • point them to needed set of plot formats

• Answer questions over Part 1 and provide time to work.