Amorphophallus Konjac

Voodoo Lily

Konjac in Kitchen

I finally caught my A. Konjac blooming.
Most of my tropicals spend the winter sleeping in the basement. So around the ides March I miss the bloom.

A. Konjac

A. Konjac blooming in basement

This plant grows from a corm which sends a single flower up for a single day, right around this time of the year. Then, later in the spring, a several foot tall umbrella shaped plant sprouts up. The plant is actually a single leaf, but it is hard to tell that unless you watch it sprout from the start. This is a wonderful, prolific plant. Each year I give many corms away.
Late in the fall the leaf dries up and decays to nothing.
I am so excited to witness it flowering. It smells to me not so much as rotten meat, as it as often described, but as a rotten gourd.

A. Konjac

Voodoo Lily

The dog loves it.

Object Oriented Factorization Program in PHP

I love actuarial stuff.  But, when I am learning any kind of new programming or mathematics, I always think number theory.

On my deathbed, I will probably not be thinking about loss ratios.  But I will be thinking about divisibility.  Number theory is the thing that originally drew me, and many others, to mathematics.

So, in the interest of learning PHP, I wanted to put a factorization application up on my website. But I wanted to be able to factorize more than one number at a time, so that one can observe the relationship between properties of different integers. So, I thought, what I want is several instances of the factorizer. That means writing an object oriented application.
You will observe below that the constructor does all of the work. That is because number theory stuff is very calculation intensive. Many of the variables, like phi, can be calculated as by-products of other calculations.

class DestructNumber
{ var $N;
private $sumofdivisors = 0;
private $divisorlist=array();
private $primedivisorlist=array();
private $primedivisorstring;
private $phi = 1;
// this constructor does all of the work
// that allows the utility to use a more efficient
// algorithm than a strictly obect oriented approach
// would allow

public function __construct($N) { $this->number = $N;
// find half of divisors
$counter = 1;
$end = floor(sqrt($this->number));
for ($m=1; $m <= $end;$m++ ) { if ($this->number%$m == 0)
{$this->divisorlist[$counter]=$m;
$this->sumofdivisors=$this->sumofdivisors + $m;
$counter++;
}
}
//find other half of divisors
for( $m = $counter-1;$m > 0;$m--)
{
$quotient = $this->number/$this->divisorlist[$m];
if ($this->divisorlist[$m] != $quotient)
{$this->divisorlist[$counter] = $quotient;
$this->sumofdivisors=$this->sumofdivisors + $quotient;
$counter++;
}}


// extract primes
$bar=1;
for($m = 2; $m <= $counter-1; $m++) { if (DestructNumber::primep($this->divisorlist[$m]))
{$this->primedivisorlist[$bar][1]=$this->divisorlist[$m];
$bar++;}
}
//find powers of primes
for ($m=1; $m <= $bar-1; $m++) { $power=1; $x = round(pow($this->primedivisorlist[$m][1], $power));

while ($this->number % $x == 0
&& $x <= $this->number)
{
$power++;
$x = round(pow($this->primedivisorlist[$m][1], $power));
}
$this->primedivisorlist[$m][2] = $power-1;
}
// create prime divisor string
$this->primedivisorstring =””;
for ($m = 1; $m <= $bar-1;$m++) { $this->primedivisorstring .= $this->primedivisorlist[$m][1];
if ($this->primedivisorlist[$m][2]>1 )
{ $this->primedivisorstring .= ““.$this->primedivisorlist[$m][2].”“;
}
if ($m < $bar-1) {$this->primedivisorstring .= “*”;}
$this->phi = $this->phi * round(pow($this->primedivisorlist[$m][1], ($this->primedivisorlist[$m][2]-1)))*($this->primedivisorlist[$m][1]-1);
}
}

All of the work has been done by my constructor. Now, I just need some methods to return the values.

// define methods
private function primep ($N){
$stop = floor(sqrt ($N));
for ( $m=2; $m <= $stop; $m++) { if ($N%$m ==0) return 0; } return 1; } public function get_N(){ return $this->number;
}
public function get_sigma(){
return $this->sumofdivisors-$this->number;
}
public function get_numberdivisors(){
return count($this->divisorlist);
}
public function get_divisorstring(){
return $this->primedivisorstring;
}
public function get_phi(){
return $this->phi;
}
public function get_prime(){
return (count($this->divisorlist) == 2 ) ? "Yes" : "No";
}
public function get_perfect(){
return ($this->sumofdivisors == $this->number) ? "Yes" : "No";
}
public function get_square(){
return ( count($this->divisorlist)%2 == 1) ? "Yes" : "No";
}

}

There are some fun things here. A number is prime if it has two divisors. A number is square if it has an odd number of divisors.
Here is the link for my web factorizer.

Next, I will be posting a database mining application to explore number properties.

A Simple Windows Application for Factorizing Integers

So, I spend so much time working and doing mathematics and walking the dogs that I don’t always spend much time on programming. But, over the last year, I have realized that everything that I need to make windows applications is already on my computer. I don’t need any fancy software: just a text editing program, and an open source compiler to compile from the command line.
So my first code that I am posting here is a C++ application for factorizing integers. It just runs in a window with no fancy GUI. But it factorizes numbers very nicely.

The link for the downloadable exe file is below the code.

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <cstdint>
#include <string>
//  #include <NTL/ZZ.h>  get this number theory stuff eventually

bool primep (int64_t N);

int main()
{
using namespace std;
std::string another ="N";
do
{
int64_t N;
int64_t divisorlist[1000];
int64_t primedivisorlist[100][3];
int64_t sumofdivisors =0;
int64_t phi=1;
int counter (1);
bool squarep (false);
cout<< "This application factors integers of up to seventeen digits."<<endl;
cout << "Enter an integer to be factored: " <<endl;
cin>>N;
cin.ignore(32767, '\n');

for (int m=1; m<= floor(sqrt(N));m++ )
{
if (N%m == 0)
{divisorlist[counter]=m;
counter++;}
}

for(int m=counter-1;m> 0;m--)
{
int64_t quotient = N/divisorlist[m];
if (divisorlist[m] != quotient)
{divisorlist[counter]=quotient;
counter++;
}}
// now extract primes
int bar=1;
for(int m =2; m<=counter-1;m++)
{
if (primep(divisorlist[m]))
{primedivisorlist[bar][1]=divisorlist[m];
bar++;}
}
// now find powers of primes

for (int m=1; m<=bar-1; m++)
{
int power=1;
int64_t x = round(pow(primedivisorlist[m][1], power));

while (N % x ==0
&& x<=N)
{
power++;
x = round(pow(primedivisorlist[m][1], power));
}
primedivisorlist[m][2]=power-1;
}
cout<<N<<" = ";
for(int m =1; m<=bar-1;m++)

{
cout<<primedivisorlist[m][1];
if (primedivisorlist[m][2]>1 )
cout<< "^"<< primedivisorlist[m][2];
if (m<bar-1) cout<<"*";
phi=phi*round(pow(primedivisorlist[m][1], (primedivisorlist[m][2]-1)))*(primedivisorlist[m][1]-1);
}
cout<<endl;

cout<< "Number of divisors: "<<counter-1<<endl;
cout<<"The divisors are: "<<endl;
for(int m =1; m<=counter-1;m++)
{
cout<<divisorlist[m]<<" ";
sumofdivisors = sumofdivisors+divisorlist[m];
}
cout<<endl;
cout<<"The sum of the aliquot divisors of "<<N<<" is "<<sumofdivisors-N<<". Hence, this number is ";
if (sumofdivisors >(2*N)) {cout<<"abundant. "<<endl;}
else if (sumofdivisors<(2*N)){cout<<"deficient. "<<endl;}
else {cout<<"perfect. "<<endl;}

cout<<"Phi, the number of integers less than and relatively prime to "<<N<<" is "<<phi<<endl;
cout<<N<<" is ";
if (primep (N))
cout<<" ";
else cout<<"not ";
cout<<"prime."<<endl;
squarep = (counter-1)%2;
cout<<N<<" is ";
if (squarep)
cout<<" ";
else cout<<"not ";
cout<<"a perfect square."<<endl;
cout<<"Another number? ";

std::getline(std::cin, another);
}
while ((another == "yes") || (another == "y"));

return 0;
}

bool primep (int64_t N)

//returns t if N is prime
{
for (int m=2; m<= floor(sqrt (N)); m++)
{
if (N%m ==0) return false;
}
return 1;
}

The code is very simple and self-explanatory.  It is not the most efficient and beautiful way to factorize a number, but it works well enough within the realm of integers that can be easily handled by the base C++ variable types.

Here is the link for the exe file:

Factorizer

Multi-Period Binomial Options

Here is my latest program for calculating the prices of options using a multi-period binomial tree. It works, but represents a bunch of strange methods to solve unexpected problems.
First, I decided to calculate the price at each node by finding the price at the terminal nodes, then use a formula, rather than calculate the prices recursively. This technique, as you will see, led to the problem of calculating binomial coefficients.

The thing that I am most satisfied with is that I was able to get the program to output to a text file, which can be opened in Excel to visualize the data.  The only thing that the program does not do is to do the same calculation with the Black-Scholes formula, and visualize how the binomial calculation approaches the Black-Scholes result.

First, take a look at my output:

Binomial Pricing

We can see how the results approach a limit with each iteration.  The pricing for periods 34 and 35 is starting to get weird because of limits of integer sizes and floating point number sizes.

Here is a chart of the above data:

Binomial Option Tree

Finally, here is the code:

#include <cstdlib>
#include <iostream>
#include <cmath>
#include <iomanip>
#include <fstream>

//Calculates price of European call or put option, and portfolio required to duplicate option, using binomial tree

int nchoosek(int n,int k);
//choice holds the binomial tree so that it doesn’t need to be recalculated
unsigned long long choice [50][50]={};

int main() {
using namespace std;
float S0, r,div, K, h,t,sigma, u, d,pStar, uS,dS,Cu,Cd,delta, bondValue;
double optionPrice;
double prices [50];
int n;
string callPut;
int putTrue;
//fill in nchoosek tree
for (int m=1; m<50;m++)
{ choice [m][0]=1;
choice [m][m]=1;}
for (int m=2;m<(50);m++)
{ for (int l=1;l<m;l++){
choice[m][l]=choice[m-1][l-1]+choice[m-1][l];
}
}
//get data from user
cout<<“Calculate the price of a European call or put, using a one period binary tree, then find rate with n period tree.”<<endl;
cout<<“Current Stock Price?”;
cin>>S0;
cout<<“Continuously Compounded Risk Free Rate?”;
cin>>r;
cout<<“Continuous Dividend Rate?”;
cin>>div;
cout<<“Volatility?”;
cin>>sigma;
cout<<“Strike Price?”;
cin>>K;
cout<<“Time to Expiration?”;
cin>>t;
cout<<“Number of Periods? (less than 50 please)”;
cin>>n;
cout<<“Call or Put?”;
cin>>callPut;
if ((callPut == “put”)||(callPut==”p”))
putTrue=-1;
else putTrue=1;
//calculate likely upward and downward motions
u=exp((r-div)*t+sigma*sqrt(t));
d=exp((r-div)*t-sigma*sqrt(t));
uS=u*S0;
dS=d*S0;
cout<<“Upward Move “<<uS<<endl;
cout<<“Downward Move “<<dS<<endl;
//calculate payoff of call, given motions above
//the variable putTrue turns Us-K into K-Us.  Cool.
Cu=fmax(0, putTrue*(uS-K));
Cd=fmax(0, putTrue*(dS-K));
//calculate Delta, Beta, and call option price
delta=exp(-div * t)*(Cu-Cd)/(S0*(u-d));
bondValue=exp(-r * t)*((u*Cd)-(d*Cu))/(u-d);
optionPrice=delta*S0+bondValue;
cout<<“To duplicate the option, buy “<<delta<<” shares=”” of=”” the=”” stock=”” for=”” “<<delta*s0<<“=”” dollars=”” and=”” borrow=”” “<<-1=”” *=”” bondvalue<<“=”” at=”” rate=”” “<<r<<“=”” a=”” total=”” price=”” “<<optionprice<<<span=”” class=”hiddenSpellError” pre=”” data-mce-bogus=”1″>endl;
cout<<“Price of Option “<<optionPrice<<endl;
cout<<“Prices above 30 levels deep may accumulate errors wildly”<<endl;

//Multi Period tree
int j=1;
while(j<(n+1)){
h=t/j;
u=exp((r-div)*h+sigma*sqrt(h));
d=exp((r-div)*h-sigma*sqrt(h));
pStar=(exp((r-div)*h)-d)/(u-d);
optionPrice=0;

for (int m=0; m<(j+1); m++) {
//This is the big doozy.
//Instead of computing the price at each interior node, only the terminal nodes are calculated
//and the price is found using the binomial theorem
optionPrice=optionPrice+nchoosek(j,m)*pow(pStar,j-m)*pow((1-pStar),m)*fmax(0,(putTrue* ((S0*pow(u, j-m)*pow(d,m))-K)));
}
optionPrice=optionPrice*exp(-r*t);
prices [j]=optionPrice;
cout<<“Periods: “<<j<<”  “;
cout<<“Option Price:  “<<optionPrice<<endl;
++j;  }

//output prices to text file
//open the text file in excel
//data is delimited by commas
ofstream outf(“Results.txt”);
if (!outf)
{  cerr << “File Error”<<endl;
exit(1); }
outf<<“Depth of Tree”<<“,”<<“Price”<<endl;
j=1;
while(j<(n+1)){
outf << j <<“,”<< prices[j]<< endl;
++j;  }
return 0;}

int nchoosek(int n, int k)
{ if (n>49 ||k>49)return 0;
else { return choice[n][k]; }}

The heart of everything is this ugly beast:

optionPrice=optionPrice+nchoosek(j,m)*pow(pStar,j-m)*pow((1-pStar),m)*fmax(0,(putTrue* ((S0*pow(u, j-m)*pow(d,m))-K)));

This is better put as C=C+\binom j m p^{*^{j-m}}(1-p*)^m*max(0,put(S_ou^{j-m}d^m-K)

You can figure out why this works fairly easily.  I like the bit where I multiply (F_{0,T}-K) by -1 to get (K-F_{0,T}.

More than anything, this exercise shows how errors creep into these long calculations.  Looking at the graph, you can see how our numbers are already wandering away from the correct numbers after the 20th iteration.

A Simple C++ Program for Computing Binomial Option Prices

I have been advised that C++ and VBA are commonly requested languages for actuaries. So, while I am studying for exam MFE, I have been writing simple programs.  My native language is LISP.  I like its beauty, and its adaptability.  I am sure that C++ has its promoters, but I think that it is a shame that such an ugly programming language has become one of the most used.

Of course, I am still a novice to the language, so my code is still extra ugly.

Computes call price using binomial model:

#include <cstdlib>
#include <iostream>
#include <cmath>
#include <iomanip>

//Calculates price of call option, and portfolio required to duplicate option, using binomial tree

int main() {
using namespace std;
    float S0, r,div, K, h, sigma, u, d, uS,dS,Cu,Cd,delta, bondValue, callPrice;
//get data
    cout<<“Calculate the price of a call, using a one period binary tree”<<endl;
    cout<<“Current Stock Price?”;
    cin>>S0;
    cout<<“Continuously Compounded Risk Free Rate?”;
    cin>>r;
    cout<<“Continuous Dividend Rate?”;
    cin>>div;
    cout<<“Strike Price?”;
    cin>>K;
    cout<<“Time to Expiration?”;
    cin>>h;
    cout<<“Volatility?”;
    cin>>sigma;
//calculate likely upward and downward motions
    u=exp((r-div)*h+sigma*sqrt(h));
    d=exp((r-div)*h-sigma*sqrt(h));
    uS=u*S0;
    dS=d*S0;
    cout<<“Upward Move “<<uS<<endl;
    cout<<“Downward Move “<<dS<<endl;
//calculate payoff of call, given motions above
    if (uS > K)
    Cu = uS-K;
    else Cu = 0;
    if (dS > K)
    Cd = dS-K;
    else Cd = 0;
//calculate Delta, Beta, and call option price
    delta=exp(-div * h)*(Cu-Cd)/(S0*(u-d));
    bondValue=exp(-r * h)*((u*Cd)-(d*Cu))/(u-d);
    callPrice=delta*S0+bondValue;
    cout<<“To duplicate the call, buy “<<delta<<” shares=”” of=”” the=”” stock=”” for=”” “<<delta*s0<<“=”” dollars=”” and=”” borrow=”” “<<-1=”” *=”” bondvalue<<“=”” at=”” rate=”” “<<r<<“=”” a=”” total=”” price=”” “<<callprice<<<span=”” class=”hiddenSpellError” pre=”” data-mce-bogus=”1″>endl;
    cout<<“Price of Call “<<callPrice<<endl;

//find the price of some other related calls
    cout<<“Some other Call prices: “<<endl;
    float step;
    step = 0.05*K;
    K= K-5*step;
       for (int z=0;z<11;z++){
       if (uS > K)
    Cu = uS-K;
    else Cu = 0;
    if (dS > K)
    Cd = dS-K;
    else Cd = 0;

    delta=exp(-div * h)*(Cu-Cd)/(S0*(u-d));
    bondValue=exp(-r * h)*((u*Cd)-(d*Cu))/(u-d);
    callPrice=delta*S0+bondValue;

    cout<<setw(8)<<k<<” “<<callprice<<<span=”” class=”hiddenSpellError” pre=”” data-mce-bogus=”1″>endl;
    K=K+step;
}
    return 0;
}
//Wow what an ugly program

Here is a sample run:

Binomial option pricing

JobSearch Database: Hacked

Work season is slowing.  Hence, it is time for us to resume our search for a new job.  When last we visited this project, we were building a database application which would streamline the job search process.  At this point, however, we have better things to do (for example, study for our next exam) than to build a theoretically correct database.  And yet, we still have need of a way of making our search for employment more efficient.  What we need is a workflow.

After digging through our computer for a utility for the task, we settle on FreeMind.  It is intuitive, adaptable, dependable, and we have used it in the past.

The best way to illustrate this is with screenshots.

jobsearchWorkflow1

Job Search Workflow Mindmap

FreeMind is mind mapping software that uses a hierarchical tree structure (compare this to something like Cmap tools that is more free-form).  We don’t need a tree structure, but we do need easy hyperlinks, which we know that FreeMind has.

jobsearchWorkflow2

Format of companies to add.

We don’t have anything in our “Companies to Add” file right now, except for a model of the vital information that we need about each company ( the login, password, and HRC rating).

jobsearchWorkflow3

Some prospective companies which employ actuaries.

The “Companies” file contains links for each companies website, plus the vital login info (each node may be unfolded).

jobsearchWorkflow4

Nodes for job listings.

When we identify a job to apply for, we drag a copy of the company info down to the job prospects file, then copy the job listing webpage on to the system, and link to it.

jobsearchWorkflow5

Nodes for jobs applied.

Once we apply for a job, the listing is dragged down into the jobs applied file, and links for the resume and cover letter are added.

From a database point of view, there are flaws, such as data duplication.  However, thinking about this from a workflow point of view was very helpful.

Some Study Materials For Exam MFE

It looks like I will take MFE, Models For Financial Economics, in March, 2015. The best source for the information is the SOA page for the test. It has links for the current Syllabus, the sample problems, and video solutions from the Wisconsin School of Business. The great thing about this exam is that the only recommended study resource is the MacDonald book, which we all still have from exam FM.

G. Stolyarov II has a very nice free study guide. At first glance I like it, and I like his studying hints.

Beyond that, I will be creating study cards again, reviewing FM material, and probably using Coaching Actuaries. Once again I will be studying to instrumental jazz music.  My goal is to get to the point of taking timed exams a few weeks before the actual exam.  So, my countdown on the sidebar will be to February 20, but I will be taking the actual exam somewhere around the ides of March.

Wish me luck.

Eight Secret Tricks to Passing (Exam FM)

1.  Be over-prepared: The syllabus is so extensive, and there are so many twists that may be put on standard material, that there are always going to be questions that look foreign. The more that you are prepared, the more that you will be able to handle some of these. Being over prepared also helps to deal with emotions. There were points during the exam when a little voice in my head said “There is no way that you are going to pass this.” Yet, that same voice was in my head during many sample exams which I passed with flying colors. Experience and over-preparation reveals that you can succeed even when you are not at your best. If you walk into the exam center with worries, or a cold,or the flu, or pain in your back, you know that you can still succeed.

2.  Fill in the tough spots: It can hurt your head to learn new things. Identify the areas with which you struggle, and try to get your head around them. Two weeks before the exam, I still had some head-pain topics. Things like duration matching, convexity, interest rate swaps, and put-call parity. But, they were on my daily study schedule, and I forced myself to confront them each day. It paid off.

3.  Fill in the fundamentals: Once you gain proficiency in a topic, the fundamentals look different. In the month before the test, I went back and reviewed some of the basics of interest theory. At this point, the basics were easy, and I picked up on some of the finer points that I missed the first time around. Amortization schedules, for instance.  After I learned the basic formulas, it was easy to ignore the schedules they are based on. Yet many problems are made much easier by using schedules, rather than relying on formulas.

4.  Memorization is easy: Once you understand things thoroughly, you don’t really need to do much memory work for these exams. After months of working problems, most things will be anchored in your head. And yet suppose that you find yourself trapped in a dark alley by two annuities, one of which is twice as long as the other. Then you will be glad that you memorized \frac{a_{\overline{2n}\lvert }}{a_{\overline{n}\lvert }}=1-v^n I have never encountered this fact in practice, but if I did, recognizing this identity might save me a couple of minutes. Spend a little time on memory work, it is easy.

5.  Test symbolic solutions with numbers: If you have a problem with a purely symbolic solution, and you can narrow it down to a couple of possible solutions, you can frequently replace the variables with reasonable numbers, and see if the result is true. This is my favorite new solution technique I learned while studying for this exam.

6.  Read MacDonald: Actually read it. After you learn the math, go back and read it. If you look at the notes from the sample problems, you will notice that the exam writers have made it pretty clear that the exam will be based on the book. Those non-numeric multiple choice questions can be very challenging. Read the book.

7.  Number your Scrap Paper: I learned this trick when taking practice exams.  If you have time to review problems at the end of the exam, you will need to find the scratch-work easily.

8.  Practice with dull number two pencils: Two weeks before the exam, I put all of my mechanical pencils away, and worked only with old fangled sharpenable pencils. Two hours into the exam, you will be working with dull stubs, so you need to be prepared.