# Amorphophallus Konjac

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 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.

Voodoo Lily

The dog loves it.

# Integer Sequence Explorer

My integer sequence database explorer is finally up and running over at my website.  Essentially, this application allows the user to choose two integer sequences from many common sequences, then runs a query which selects common members from each sequence.

One of the interesting tasks has been to write many small applications which produce the sequences to be loaded into the database relations.  I started out a little too optimistic, and wrote code which calculated the first million primes, squares, sum of divisors, and others.  I quickly found that when I ran queries on these tables, they took way to long, and my server was timing out.  I incrementally scaled things back until I was left with the first 10,000 members of most sequences.  Now my task is to re-design the database to allow for larger searches.

I will be loading up more sequences over the next few weeks, and posting explanations and links for the sequences.

# 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:

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:

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:

# New Study Materials for Exam FM

You may have noticed that I have been adding some study materials to my blog, as a side project. If you click on the “Easy FM Quizes” tab, you will find some interactive quiz problems. These are dumped over from my easy practice problems I made when I was studying for the exam. I have more than 1000 more exercises that I will transfer over in the coming weeks.
I am even more excited about the exercises that I am putting into nice PDF problem sets.  If you have heard me talk about math, you know that I learned algebra and calculus from early 20th century text books.  I have a sentimental attachment to the problem sets at the ends of chapters.  It has given me great satisfaction to write at simple LaTeX class that duplicates the feel of these textbook problems.  When I am done, they will be a single document.
The links for these problem sets will be posted on the right side bar.

Enjoy!

# 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.

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.

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).

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).

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.

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.