Douglas, M. (2001). Trading in the Zone: Master the Market with Confidence, Discipline and a Winning Attitude. Prentice Hall Press

Douglas, M. (2001). Trading in the Zone: Master the Market with Confidence, Discipline and a Winning Attitude. Prentice Hall Press

Enable USB debugging.
Connect your phone to your computer.
Bring up a command prompt.
Change to android-sdk-windows directory.

adb remount
adb shell
cd system/media/audio/ui
mv camera_click.ogg camera_click.og_
mv VideoRecord.ogg VideoRecord.og_

Source: http://android.modaco.com/topic/319541-camera-shutter-sound/
Reference: http://theunlockr.com/2009/10/06/how-to-set-up-adb-usb-drivers-for-android-devices/

At time of rooting, the specs were:

BravoC DVT2 Ship S-on
HBOOT-1.06.0000
Microp-051e
Touch Panel-Synt0101
Radio-2.15.00.2.17
Dec 22, 2010, 16:16:39

Abridged Instructions:

1. Download/Install HTCDriver3.0.0.007 (AKA Fastboot drivers)
2. Download/Apply revolutionary-0.3pre7 (Boot/Recovery loader)
3. Download/Apply su-2.3.6.3-efgh-signed (root)
4. … ClockworkMod backup!! (protect your original OEM install)
5. ClockworkMod to wipe data/cache (now wipe it clean)
6. ClockworkMod to create/format 512MB sd-ext partition (add partition for apps)
7. Download/Apply CyanogenMod 7 – update-cm-7.0.3-BravoC-signed (the ROM for your device)
8. Android Market > S2E > configure (check all) > reboot (Use sd-ext thoroughly: more apps, long reboot)
9. Android Market madness! (download away!)
10. Software configuration madness… (configure before backup snapshot)
11. … ClockworkMod backup!!! (make backup of customized OS)
12. AWESOME (do dangerous things, knowing you have a backup!)

Learning curve: 7 hours of pain + 2 hours of tinkering + 2 hours of diligent due process, 30 minutes of documentation.

Unlock device, install boot loader, root:
http://theunlockr.com/2011/08/02/how-to-gain-s-off-flash-a-custom-recovery-and-root-your-android-phone-using-the-revolutionary-method/

Choose your mod (not very many for CDMA):
http://forum.cyanogenmod.com/forum/118-htc-desire-cdma/

Force use of newly created sd card ext partition (get lots of app space):
https://market.android.com/details?id=ru.krikun.s2e

*Background info re. the apps data partition/A2SD conundrum:
http://android.modaco.com/topic/331205-guide-how-to-get-more-free-space-for-your-apps/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

/**
 * Computes the Parabolic SAR, as originally developed by Welles Wilder.
 *
 * @param array $his Extreme Points: The highest high
 * @param array $los Extreme Points: The lowest low
 * @param float $afInc Acceleration Factor Increment, for each time point
 *   Lower increment = less sensitive (indicitive)
 * @param float $afMax Acceleration Factor Max, rno matter how long the trend
 *   Lower max step = less sensitive (reactive)
 * @param bool $withDir Indicates if trend direction should be returned.
 * @return array 
 *  If $withDir is true, result is tuple of length 2.
 *    Tuple contains ( array of SAR values, array of trend direction )
 *  Else if $withDir is false, result is simply an array of SAR values.
 */
function parabolicSAR($his,$los,$afInc=0.02,$afMax=0.20,$withDir=false) {
 if( !is_array($his) || !is_array($los) ) {
   trigger_error("First 2 parameters must be arrays: his, los",E_USER_WARNING);
   return ($withDir) ? array(false,false) : false;
 }
 if( count($his) != count($los) ) { 
   trigger_error("Arrays must be equal length.", E_USER_ERROR);
   return ($withDir) ? array(false,false) : false;
 }
 if( count($his) < 2 ) { 
   return ($withDir) ? array(array(),array()) : array();
 }
 
 $keys = array_keys($his);
 $his = array_values($his);
 $los = array_values($los);
 
 // Initialize trend to whatever
 $trend = ($his[1]>=$his[0] || $los[0]<=$los[1]) ? +1 : -1;
 
 // Previous SAR: Use first data point&#039;s extreme value, depending on trend
 $pSAR = ($trend>0) ? $los[0] : $his[0];
 
 // Extreme point: Highest during uptrend || lowest during downtrend
 $EP = ($trend>0) ? $his[0] : $los[0];
 
 // Acceleration factor
 $AF = $afInc;
 
 // Initialize results based on trend guess
 $r = array($keys[0] => $pSAR);   // SAR Results
 $d = array($keys[0] => $trend);  // Trend Directions
 
 // Compute "tomorrow" SAR
 for($i=1,$n=count($keys)-1; $i<$n; $i++) {
   // Do for uptrend
   if( $trend > 0 ) { 
 
     // Making higher highs: accelerate
     if( $his[$i] > $EP ) {
       $EP = $his[$i];
       $AF = min($afMax,$AF+$afInc);
     }
 
     // Tomorrow&#039;s SAR based on today&#039;s price action.
     $nSAR = $pSAR + $AF * ($EP - $pSAR);
 
     // Rule: SAR can never be above prior period&#039;s low or the current low.
     $nSAR = ($i>0) ? min($los[$i],$los[$i-1],$nSAR) : min($los[$i],$nSAR);
 
     // Rule: If SAR crosses tomorrow&#039;s price range, the trend switches.
     if( $nSAR > $los[$i+1] ) { 
       $trend = -1;
       $nSAR = $EP;      // set to the last EP recorded on the previous trend
       $EP = $los[$i+1]; // reset accordingly to this period&#039;s maximum
       $AF = $afInc;     // reset to its initial value of 0.02.
     }
 
   } else {
   // Do for downtrend
 
     // Making lower lows: accelerate
     if( $los[$i] < $EP ) { 
       $EP = $los[$i];
       $AF = min($afMax,$AF+$afInc);
     }
 
     // Tomorrow&#039;s SAR based on today&#039;s price action.
     $nSAR = $pSAR + $AF * ($EP - $pSAR);
 
     // Rule: SAR can never be below prior period&#039;s highs or the current high.
     $nSAR = ($i>0) ? max($his[$i],$his[$i-1],$nSAR) : max($his[$i],$nSAR);
 
     // Rule: If SAR crosses tomorrow&#039;s price range, the trend switches.
     if( $nSAR < $his[$i+1] ) {
       $trend = +1;
       $nSAR = $EP;      // set to the last EP recorded on the previous trend
       $EP = $his[$i+1]; // reset accordingly to this period&#039;s maximum
       $AF = $afInc;     // reset to its initial value of 0.02.
     }
 
   } // end: if uptrend else downtrend
 
   $r[$keys[$i+1]] = $nSAR;
   $d[$keys[$i+1]] = $trend;
   $pSAR = $nSAR;
 } // END: for(i..n)
 
 return ($withDir) ? array($r,$d) : $r;
} // END: function parabolicSAR($his,$los,$afInc=0.02,$afMax=0.20)

Sources:

• StockCharts.com: Chart School
• Wikipedia: Parabolic SAR

1) Setup/Tutorial: http://www.unidata.ucar.edu/projects/THREDDS/tech/tds4.2/tutorial/

2) Installation Checklist: http://www.unidata.ucar.edu/projects/THREDDS/tech/tds4.2/tutorial/Checklist.html

3) Download/Documents: http://www.unidata.ucar.edu/projects/THREDDS/tech/TDS.html

Top 10 (excerpt):

The results can be found here: University Ranking, Source Code.

My assumption is that the higher the reading level, the more intelligent the professors are at their respective universities. With this premise, one can use the search results to rank the universities accordingly.

This assumption comes with several caveats. One such example includes the situation where publications are not hosted under the university’s primary domain. While I haven’t found this to be the case, I cannot prove otherwise. The results are clearly biased in favor of universities with more publications online. This is justified in that the prodigious universities will publish more papers than their less substantial counterparts.

The ranking algorithm: (3*advanced + 2*intermediate + 1*basic) * num_documents

The primary caveat is that Google returns the percentage of documents for one of 3 reading levels, as well as the number of search results. By multiplying the result count by the percent, we calculate the number of documents at the advanced, intermediate and basic reading levels. However, we can’t simply sort our results by raw numbers alone. For example, a school that has 100 advanced level, 800 intermediate level, and 100 basic level documents should not be ranked lower than a school that has 101 advanced level, 100 intermediate level, and 800 basic level documents. In fact, the basic level documents negatively weights on the second school. For this to be the case, one must apply scaling factors to each of the reading levels. Unfortunately, these scaling factors may be selected arbitrarily, and may also be subjective.

Final caveat: The comparison is done on reading level and documents available online. For a school that emphasizes publishing papers, the results will be weighted in its favor. For a school that emphasizes the arts, the advanced reading level metric becomes less important.

References:
List of American Universities
Google Search [site:log.largevoid.com]

The long and short of it is to set up a local SOCKS5 proxy with putty. Simply open up putty, go to Connection>SSH>Tunnels. Add a new forwarded port (say 1080), make it dynamic, then hit add. Now log in to your remote machine and you have a local SOCKS5 proxy running on port 1080. You can then point your browser to use this proxy for all your web traffic.

The link also mentions how to make Firefox tunnel DNS requests for added security, but I won’t go into that.

Happy safe browsing!

List comprehension:

Create a list from a function and filter:

S = [2*x for x in range(101) if x**2 > 3]

Generator

Define a generator:

from itertools import count
 
def generate_primes(stop_at=0):
    primes = []
    for n in count(2):
        if 0 < stop_at < n:
            return # raises the StopIteration exception
        composite = False
        for p in primes:
            if not n % p:
                composite = True
                break
            elif p**2 > n:
                break
        if not composite:
            primes.append(n)
            yield n

Using a generator:

for i in generate_primes():  # iterate over ALL primes
    if i > 100:
        break
    print i

map (source):

def cube(x): return x*x*x
map(cube, range(1, 11))  # outputs [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

seq = range(8)
def add(x, y): return x+y
map(add, seq, seq)  # outputs [0, 2, 4, 6, 8, 10, 12, 14]

reduce (source):

def add(x,y): return x+y
reduce(add, range(1, 11))  # outputs 55

filter (source):

def f(x): return x % 2 != 0 and x % 3 != 0
filter(f, range(2, 25))  # outputs [5, 7, 11, 13, 17, 19, 23]

iter (source):

for value in sequence:
    print(value)

for key in dictionary:
    value = dictionary[key]
    print(key, value)

for key, value in dictionary.items():
    print(key, value)

range (source):

a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
    print i, a[i]

xrange (source):

z = lambda x, h: [sum((x[i - j] if (0 <= i - j < len(x)) else 0) * h[j] \
for j in xrange(len(h))) \
for i in xrange(len(x) + len(h) - 1)]

Decorators:

class C(object):
 
    @staticmethod
    @funcattrs(grammar="'@' dotted_name [ '(' [arglist] ')' ]",
               status="experimental", author="BDFL")
    def longMethodNameForEffect(longArgumentOne=None,
                                longArgumentTwo=42):
        """This method blah, blah.
 
        It supports the following arguments:
        - longArgumentOne -- a string giving ...
        - longArgumentTwo -- a number giving ...
 
        blah, blah.
 
        """
        raise NotYetImplemented

Strategy Pattern:
Example usage:

class Button:
    """A very basic button widget."""
    def __init__(self, submit_func, label):
        self.on_submit = submit_func   # Set the strategy function directly
        self.label = label
 
# Create two instances with different strategies
button1 = Button(sum, "Add 'em")
button2 = Button(lambda nums: " ".join(map(str, nums)), "Join 'em")
 
# Test each button
numbers = range(1, 10)   # A list of numbers 1 through 9
print button1.on_submit(numbers)   # displays "45"
print button2.on_submit(numbers)   # displays "1 2 3 4 5 6 7 8 9"

See documentation for:

• itertools
• functools

This post was inspired by an item on StackOverflow: Python Progression Path from Apprentice to Guru

Background
Using DCF analysis to compute the NPV takes as input cash flows and a discount rate and gives as output a price; the opposite process – taking cash flows and a price and inferring a discount rate, is called the yield.

Definitions
FV = DPV * (1+i)^n
DPV = FV/(1+i)^n = FV * (1-d)^n

DPV: discounted present value
FV: future cash flow; nominal value of cache flow in future
i: interest rate
d: discount rate { i/(1+i) } ; interest rate subtracted from BoY; rather than added at end of year
n: time in years before future cash flow

Summing multiple cash flows:
DPV = SUM{t=0..N} of { FV[t]/(1+i)^t }

An Example
“John Doe buys a house for $100,000. Three years later, he expects to be able to sell this house for $150,000.”

“the 3-year US Treasury Note rate is 5% per annum.”

“Using the DPV formula (FV=$150,000, i=0.05, n=3), that means that the value of $150,000 received in three years actually has a present value of $129,576 (rounded off).”

“Subtracting the purchase price of the house ($100,000) from the present value results in the net present value [(NPV)] of the whole transaction, which would be $29,576…”

“Another way of looking at the deal as the excess return achieved (over the risk-free rate) is (14.5%-5.0%)/(100%+5%) or approximately 9.0% (still very respectable). (As a check, 1.050 x 1.090 = 1.145 approximately.)”

Set your DNS to use Google’s DNS:
8.8.8.8 and 8.8.4.4

Then flush the existing DNS cache and register the new DNS.

In Windows 7, you’ll need elevated privileges to changes to the DNS. Make sure you start cmd.exe as Administrator.

1. Press the window Key
2. Type “cmd”
3. Right click the cmd.exe that’s found.
4. Select “Run as administrator”
5. Type ipconfig /flushdns
6. Then type ipconfig /registerdns

Now you’re free to roam the internet.

int hash(const void * str) {
  int val = 0;
  const char *ptr;
  int tmp;
 
  while (*ptr != '\0') {
    val = (val << 4) + (*ptr);
    if (tmp = (val & 0xf0000000)) {
      val = val ^ (tmp >> 24);
      val = val ^ tmp;
    }
  }
  ptr++;
  return val;
}

Or in PHP:

function hash($str) { 
  var $val = 0;
  for($i=0,$n=strlen($str); $i<$n; $i++) {
    $val = ($val<<4) + ord($str{$i});
    if( $tmp = ($val & 0xf0000000) ) { 
      $val = $val ^ ($tmp>>24);
      $val = $val ^ $tmp;
    }
  }
  return $val;
}

Now all you have to do is mod the returned value by the size of the hash table and you have the target address for the first pass of a hash table with double-hashing.

Naive:

function interest($initial=1000,$apr=0.015,$years=10) {
  $rate = $apr/12;
  $periods = 12*$years;
  $sum = $initial;
  for($i=0; $i<$periods;$i++) {
    $sum = $sum + $sum * $rate;
  }
  return $sum;
}

Log style:

function interest($initial=1000,$apr=0.015,$years=10) {
  $rate = $apr/12;
  $periods = 12*$years;
  return $initial * pow(1 + $rate, $periods);
}

Watch the boundary conditions. The above assumes the compounding occurs 12 times. Note that this log approach would not be appropriate if we were to add money to the fund after the compounding began. If the amount added per compounding period were consistent, we could devise a new log scheme.

Naive with additions:

function interest($initial=1000,$addition=100,$apr=0.015,$years=10) {
  $rate = $apr/12;
  $periods = 12*$years;
  $sum = $initial;
  for($i=0; $i<$periods; $i++) { 
    // Add interest earned in previous term.
    // Add $addition in preparation for next compounding period.
    $sum = $sum + $sum*$rate + $addition;
  }
  // Remove last $addition because there is no addition at the end-of-term.
  return $sum - $addition;
}

Log (via Geometric Series) with additions:

/**
 * Compute the balance on an account after some period of time.
 * The account may receive an initial deposit and/or regular deposits
 * at the start of every compounding period, after the first.
 * The APR, duration, and number of compounding periods may be specified.
 *
 * @see http://en.wikipedia.org/wiki/Geometric_series
 * @param float $inital Initial deposit amount
 * @param float $addition Amount added at start of each compounding period
 * @param float $apr Annual percentage rate (percent/100) earned on balance
 * @param float $years Number of years ($years>0) to compute interest for.
 * @param uint $ppyr Number of compounding periods per year.
 * @return float Balance after $years time accruing interest at $apr rate.
 */
function interest($initial=1000,$addition=100,$apr=0.015,$years=10,$ppyr=12) {
  // Use geometric series to calculate the cumulative rate of return
  // with recurring, inter-period deposits (periods 0..N-1)
  // $initial is initial deposit, interest accrues immediately.
  // $rate is interest earned per period (percent/100).
  // $addition is amount added at beginning of period after first period.
 
  // Over time, interest accrues on the additional deposits:
  // let R = (1 + rate)
  // v0 = 0  -- we'll deal with the initial deposit elsewhere.
  // v1 = v0 * R + additional
  // v2 = (v1) * R + additional
  // v2 = (v0 * R + add) * R + add
  // v2 = 0 + add*R + add
  // v2 = add*R + add
  // v3 = v2 * R + add
  // v3 = (add*R + add)*R + add
  // v3 = add(R^2 + R + 1)
  // v4 = v3 * R + add
  // v4 = (add*R*R + add*R + add)*R + add
  // v4 = add(R^3+R^2+R^1+R^0)
  // v5 = v4 * R + add
  // v5 = (v3 * R + add) * R + add
  // v5 = ((v2 * R + add) * R + add) * R + add
  // v5 = (((v1 * R + add) * R + add) * R + add) * R + add
  // v5 = ((((v0 * R + add) * R + add) * R + add) * R + add) * R + add
  // v5 = add * (R^4 + R^3 + R^2 + R^1 + R^0)
  // ... using geometric series ... a = add, r = (1+rate)
  // vN = a * (1 - pow(r,N)) / (1-r)
 
  $rate = $apr / $ppyr;
  $periods = $years * $ppyr;
 
  // Geometric series:
  // a + ar + ar^2 + ar^3 + ... + ar^n 
  //   = sum(k=0..n)[ar^k]
  //   = a * (1-r^(n+1)) / (1-r)
  // Where:
  //   a = $addition
  //   r = 1 + $rate
  //   n = $periods - 1
  //   k = [0..n]
  $a = $addition;
  $r = 1 + $rate;
  // Compute series from first period to last period
  $geom = $a * (1 - pow($r,$periods)) / (1-$r);
  // Remove $add from last period because next period didn't begin yet.
  $additional = $geom - $addition;
 
  // Compute interest on initial deposit + additional interest from above.
  return $initial * pow(1+$rate,$periods) + $additional;
}

Same as above, but without all those comments:

function interest($initial=1000,$addition=100,$apr=0.015,$years=10,$ppyr=12) {
  $R = 1 + $apr / $ppyr;
  $pow = pow( $R, $years * $ppyr );
  return ($initial * $pow) + ($addition * (1 - $pow) / (1-$R) - $addition);
}

Of note, there is a good example of using iptables, and a description of how to bind your local mysql client to a remote mysql server.

http://www.cyberciti.biz/tips/how-do-i-enable-remote-access-to-mysql-database-server.html

Ref: LaunchPad » Ubuntu » Questions » Question #108951