Shriphani Palakodety » Mathematics

Predicting Which Hiragana Character You’re Drawing

Shriphani — Tue, 24 Jan 2012 20:24:19 +0000

I tried to take a shot @ the problem shown above. Turns out just high-school level math is sufficient to make a decent classifier for this.

In the Japanese alphabet(s), a character is composed of strokes. These strokes have a fixed order. This restriction is pretty much all you need. I grab the stroke’s end points and centroid and then normalize.

Once, a stroke is finished, a nearest-neighbor classifier runs and fetches 3 best matches. I have had very decent performance with this approach. Right now, no information about the distance between successive strokes is used. Incorporating that should improve performance by a significant amount.

Here’s a video of the classifier in action:

The full source code (very kludgy) is on github.

I have further ideas on improving the perf and training with some Kanji.

Enjoy :)

Communicating Through Fingertips – Finger Gesture Recognition Using Depth Data

Shriphani — Sun, 11 Dec 2011 03:41:48 +0000

In Prof. Vishy’s ML class (cs 590 – top notch course, top notch professor), we don’t have a final and instead we are supposed to apply ML to a problem we find interesting. Microsoft gave all of us interns a Kinect this summer so I decided to put it to some use (I don’t have a TV so the XBox is just collecting dust).

My goal was to be able to record finger gestures and then detect them when a user makes these gestures. I had 2 goals in mind – no OpenCV (i.e. I will use just depth data) and no wearing special stuff to guide anything.

So, let us see what I did. Basically, I used the CandescentNUI Hand Tracker to get a collection of fingertip locations and points and then applied two techniques to try and recognize the gestures we make.

First, I tried using the Passive-Aggressive algorithm by Crammer et. al. This algorithm uses an online-learning approach to build a hyperplane (in 3 dimensions, this is a plane, in 2 dimensions – a line etc. Basically, this is what is defined when you try to define a “surface” like structure for a space. Take 2 non-parallel vectors in 3D space and you can construct the entirety of the 2D world. The hyperplane is just that – an entire space (a subspace with 1 dim less than the one we are operating in).

The hyperplane is supposed to act like a brick wall (if we’re in 3D – no point visualizing a higher dimension). When we see a new data point come in, we want to inspect on which side of the wall it lies and then we can “detect” or label this point. This is the binary classifier.

The dataset consists of raw point coordinates in the space of the human palm seen by the kinect. Now it turns out that the online passive-aggressive algorithm fails at constructing a decent hyperplane separating 2 classes (data points for 2 different gestures).

The obvious hack was to deploy a nearest neighbors classifier. The trick I used was that I ran a large cluster k-means on the data and built myself a dataset consisting entirely of cluster centers. So I was able to reduce the neighbors tenfold and still get fantastic performance. A simple technique worked fabulously in this situation and I couldn’t be more pleased.

Here is a video of the gesture-detector in action. The annotations should show you what to look @

The source is up on github. The code is very kludgy and I will fix it up after finals week. In case you’re in a hurry : http://github.com/shriphani/KinectSpell

Now, it is time to try and avoid failing in the finals x(.

Summer and Fall 2010 + SURF 2010

Shriphani — Thu, 26 Aug 2010 05:03:07 +0000

So, 4 days into this semester I think I have decided my schedule. I am assuming I have a relatively light semester owing to some stupidity I engaged in (screw ups with the coursework). Anyway, here’s my coursework for this semester:

CS 352 – Compilers (supposed to be hard)
CS 314 – Numerical Methods (this course looked very interesting).
MA 375 – Discrete Math (to consolidate my probability concepts and to study graphs deeply)
COM 217 – Had to take it sometime.
CS 490 – Bioinformatics independent study.

So, I chickened out of ECE 270 since Compilers + Digital Systems would be suicide and since CS 497 is planned for semester #6, I am in a tight spot since one more CS course can cause my GPA in all courses to tank so I am stuck here with this stupid setup. Also, I took the Phy test out and I am not sure if that went very well so I will have to wait.

Anyway, enough about the current semester. Summer was the most eventful time of my 2 years here @ Purdue. First, I worked for Dr. David S. Ebert in his Visualization laboratory (PURPL) on an emergency response system (the project screenshots shown there are still old. They probably won’t be updated in a while). It was extremely interesting since I got to work with OpenGL (I am not sure I will ever get a chance to work with it again) and got to learn about computer graphics. Here is a list of things we got done in the summer:

A 3D picking algorithm (nothing too fancy. This took a while since I had to read OpenGL documentation about their coordinate systems).
A controllable camera (one you can turn, zoom in/out with using keystrokes)
A couple of camera angles (The high angle mode and the first person mode). Getting them to follow characters smoothly was a crazy issue.
Then we implemented a path based attribute visualization technique which became the topic for my poster.

I stood with a poster @ the SURF symposium and I won “Top Poster” and my grad mentor, S. Kim, earned “Graduate Student Mentor of the Summer” so I would rate my SURF 2010 experience as one of the top 10 experiences of my life (the other 9 are yet to arrive).

Now, I might just go and join SIG-APP or something like that to spend spare time. Now, here are some goals I set for myself this semester:

Prepare for the GRE (it sucks but it has to be done).
Learn how to speak Japanese reasonably well.
Consolidate my probability knowledge (I would really like to learn it well this time round).
Finish reading a book on NP Complete problems.

Well, I just hope I don’t screw up anything this year since this is my last chance to build a great resume for grad school (and achieve some lofty goals which are too childish for even this blog) before applications season begins.

Bipartite Matching And Max Flow – Tweaks And Other Observations

Shriphani — Sat, 17 Jul 2010 00:45:16 +0000

When I was in Dr. Frederickson’s CS 381 class (if you go to Purdue CS and are wondering if you should sit in his CS 381, I would say YES), I learned how to solve a simple class of Matching problems, biparitite matching.

So, you have 2 sets of vertices and no 2 members of the same set are connected. Now, given a bipartite graph, we are supposed to find a maximum matching for it.

The simplest way to solve this problem would be to use integer valued flow. Here’s our sample graph:

Well, the obvious solution is to direct the edges from the set on the left (marked L in the pic below) to the set on the right (marked R in the pic below) and to make a source vertex and a sink vertex. Next, to apply integer valued flow algorithms on this network, set the capacity of each edge to 1.

PS, I haven’t noted the capacities in the graph above because that would introduce too much clutter. But the capacities are indeed 1. When you run any method on this network that computes maximum integer valued flow (Choose between Ford-Fulkerson and Edmonds-Karp), you are going to have a flow of 0 or 1 on the edges in the graph. The edges that have flow = 1 on them are the ones that are included in the matching and those that are not in the matching have a flow value = 0. Here is one of the possible matchings:

The edges that are untouched have a flow value = 1 (also equal to the capacity of the edge) and those that look like they’ve been shot (i.e have holes in them, have a flow of 0 and hence are not in the matching).

Well, everyone knows this stuff. Else you wouldn’t have approached this line is < 10 seconds. Anyway, in one very productive office hour session with Dr. Frederickson, he pointed out the importance of using an approach to solve a problem. In this case, why do we set a capacity of 1 and compute max integer-valued flow? Well, considering I have a really low IQ, I had to look at this problem as if it were a communication network. Setting a capacity of 1 on each edge and then computing max flow would give us edges with a flow value of 1 or 0. That means we either use the edge to communicate or we don’t (this is why we set a capacity of 1).

So, extending this thinking to problems that bipartite matching can solve, let us consider the simple problem:

B is a set of boys who need to be paired up with girls in set G. Any boy can be paired with any girl.

So, the solution would involve what we just did.

Now, we can modify the problem so:

B is a set of boys who need to be paired up with girls in set G for a performance at their community center. Each boy can appear at most thrice and each girl can appear at most 4 times and a pair can appear at most twice.

Extending my “communication network” idea, this problem can also be solved by computing a max flow on this network. But we need to set the capacities on each edge correctly.

We have an edge from a source S to every boy. Now, a boy can appear at most thrice. This essentially means, the boy can be picked once, twice, three times (or if he really sucks, he might not be picked at all). So, the capacity you set on this edge is 3.
Now, we have an edge from every girl to a sink T. Remember a girl can be picked at most 4 times. So, the capacity of the edge from every girl to the sink is 4.
Now, each pair can appear twice so every edge from set B to set G gets a capacity of 2.

That’s it. Computing max flow on this should give us a decent matching!

Hebb’s Rule

Shriphani — Mon, 09 Feb 2009 00:58:30 +0000

This post is slightly psychology influenced. Well, in the Psychology class I have been taking this semester (Introduction To Cognitive Learning), I was taught about Neural Networks and a certain Hebb’s Rule which allows a network to remember a previous configuration and use this configuration to interpret new information. We use the following model to represent a cell:

1. A cell (neuron) has only two activation states: On or Off.

On: Cell has high firing rate. (High number of action potentials fired in unit time).
Off: Cell has low firing rate.

2. Cell weights are reciprocal. Weights symbolize the size of the synapse between two cells. Greater size = greater strength.

3. If cells fire simultaneously, they develop positive weights. The active cells (activation = on) inhibit the inactive cells (develop negative weights.

4. The network organizes itself based on sensory input. And new sensory info is interpreted by previously developed weights.

5. The network updates itself one at a time.

6. The activation of a cell can be determined by the following formula:

1 if ∑w_ija_j > 0
0 otherwise

The weights lend a sort of memory to the network since weights influence the interpretation of subsequent sensory input.

Based on these rules, I wrote something that simulated a network that implemented the Hebb’s rule.

First, we need to describe a neuron. Our neurons represent an uppercase letter of the english alphabet. We also need a way to represent the weights with each of the other neurons.

So a basic class to describe a neuron:

class Neuron:
def __init__(self, a, weight_dict):
”‘A Represents The Cell’s Content”‘

self.content = a #what letter of the alphabet a cell represents
self.weights = weight_dict #only contains contents of each neuron.
self.state = 0 #activation state initially on.

def __str__(self):
return "Activation: "+str(self.state)+"\nWeights: "+str(self.weights)

Now, the network has a collection of neurons (26 in our case which signify each letter of the alphabet). Hence, the init method for the neuron class:

def __init__(self):
self.neurons = []
self.flush = {} #weight calculator while updating activities
self.possibilities = []

for char in string.uppercase:
self.flush[char] = 0

for letter in string.uppercase:
weights = copy.copy(self.flush)
weights.pop(letter)
a = Neuron(letter, weights)
self.neurons.append(a)

Now that we have a network that is populated, we need a method that receives input and figures out the changes in the weights between cells (or the strength of the connection between cells). This method is then fed by another method that figures out the overall change in the weights and computer which cells are active:

def recvInput(self):
a = raw_input("Sensory Interface: ") #Get a word

while a != "QUIT":
b = list(a)
for i in xrange(len(b)):
for neuron in self.neurons:
char = b[i]
if neuron.content == char:
neuron.state = 1
reqd_list = b[0:i]+b[i+1:]
for char in string.uppercase:
if char in reqd_list:
neuron.weights[char]+=1
else:
if neuron.weights.has_key(char):
neuron.weights[char]-=1
else:
continue

self.checkInfo()
self.possibleInfo()
print "The possible interpretations of this input might be anagrams of the subsets of: \n"
print self.possibilities
a = raw_input("Sensory Interface: ")

def checkInfo(self):
output = []
possibilities = {}
for neuron in self.neurons:
if neuron.state == 1:
for info in neuron.weights.keys():
self.flush[info] += neuron.weights[info]
print self.flush

for neuron in self.neurons:
if self.flush[neuron.content] > 0:
neuron.state = 1
else:
neuron.state = 0

for char in self.flush.keys():
self.flush[char] = 0

def possibleInfo(self):
self.possibilities = []
for neuron in self.neurons:
if neuron.state == 1:
self.possibilities.append(neuron.content)

Then we run this network with:

words = Network()

words.recvInput()

Before I run this, let me mention that this thing only accepts uppercase letters and breaks if a letter is repeated in a word. This is because neurons rarely have their own axon connected to their own dendrite (neurons are not connected to themselves).

So, a sample run:

tark-b-183:scripts shriphani\> python hebb.py
Sensory Interface: HELP
{'A': -4, 'C': -4, 'B': -4, 'E': 3, 'D': -4, 'G': -4, 'F': -4, 'I': -4, 'H': 3, 'K': -4, 'J': -4, 'M': -4, 'L': 3, 'O': -4, 'N': -4, 'Q': -4, 'P': 3, 'S': -4, 'R': -4, 'U': -4, 'T': -4, 'W': -4, 'V': -4, 'Y': -4, 'X': -4, 'Z': -4}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'H', 'L', 'P']
Sensory Interface: LOSER
{'A': -9, 'C': -9, 'B': -9, 'E': 7, 'D': -9, 'G': -9, 'F': -9, 'I': -9, 'H': -2, 'K': -9, 'J': -9, 'M': -9, 'L': 7, 'O': 0, 'N': -9, 'Q': -9, 'P': -2, 'S': 0, 'R': 0, 'U': -9, 'T': -9, 'W': -9, 'V': -9, 'Y': -9, 'X': -9, 'Z': -9}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'L']
Sensory Interface: HOMELY
{'A': -12, 'C': -12, 'B': -12, 'E': 9, 'D': -12, 'G': -12, 'F': -12, 'I': -12, 'H': 4, 'K': -12, 'J': -12, 'M': -1, 'L': 9, 'O': 4, 'N': -12, 'Q': -12, 'P': -6, 'S': -6, 'R': -6, 'U': -12, 'T': -12, 'W': -12, 'V': -12, 'Y': -1, 'X': -12, 'Z': -12}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'H', 'L', 'O']
Sensory Interface: LOSER
{'A': -17, 'C': -17, 'B': -17, 'E': 13, 'D': -17, 'G': -17, 'F': -17, 'I': -17, 'H': -5, 'K': -17, 'J': -17, 'M': -9, 'L': 13, 'O': 8, 'N': -17, 'Q': -17, 'P': -11, 'S': 1, 'R': 1, 'U': -17, 'T': -17, 'W': -17, 'V': -17, 'Y': -9, 'X': -17, 'Z': -17}
The possible interpretations of this input might be anagrams of the subsets of: 

['E', 'L', 'O', 'R', 'S']

So we observe that in the first case, four neurons were activated. The word “LOSER” led to H and P being deactivated because the synapse weakened. The next input “HOMELY” causes H and O to activate because O began developing positive weights with other cells and when LOSER was submitted as input and developed a strong enough connection when it was seen in another sensory input. When LOSER is flashed again, it leads to H being forgotten and causes R and S to activate.

Now, a particular case which (I think) indicates the use of this “learning” technique is when we are playing scrabble. Assume that I have words such as NEAR in my memory and when I see N and E on a board, I should be able to complete these words. Watch:

Sensory Interface: NEAR
{'A': 3, 'C': -4, 'B': -4, 'E': 3, 'D': -4, 'G': -4, 'F': -4, 'I': -4, 'H': -4, 'K': -4, 'J': -4, 'M': -4, 'L': -4, 'O': -4, 'N': 3, 'Q': -4, 'P': -4, 'S': -4, 'R': 3, 'U': -4, 'T': -4, 'W': -4, 'V': -4, 'Y': -4, 'X': -4, 'Z': -4}
The possible interpretations of this input might be anagrams of the subsets of: 

['A', 'E', 'N', 'R']
Sensory Interface: NE
{'A': 1, 'C': -6, 'B': -6, 'E': 4, 'D': -6, 'G': -6, 'F': -6, 'I': -6, 'H': -6, 'K': -6, 'J': -6, 'M': -6, 'L': -6, 'O': -6, 'N': 4, 'Q': -6, 'P': -6, 'S': -6, 'R': 1, 'U': -6, 'T': -6, 'W': -6, 'V': -6, 'Y': -6, 'X': -6, 'Z': -6}
The possible interpretations of this input might be anagrams of the subsets of: 

['A', 'E', 'N', 'R']
Sensory Interface:

Well, this semester, I have already been taught some insanely great stuff. I have a bunch of exams coming up. Great scores will be the perfect way to make an awesome semester even better.

The script can be downloaded here.
The material here was used from Professor Greg Francis’ notes on Neural Learning.

Post’s Machine Emulator

Shriphani — Sat, 17 Jan 2009 19:42:35 +0000

I was bored as usual and since Combat Arms has begun to slip in my list of pastimes, I decided to write a Post’s Machine Emulator as described in the booklet by V. A. Uspensky titled “Post’s Machine” ( Amazon Link

This machine has a tape (infinitely long) and the reel has cells which can be marked or unmarked. I decided to represent a marked cell with a “1″ and an unmarked cell as “0″.

The head of this machine can move both ways and can mark and at the same time remove the mark from the other side.

The machine can be instructed using the syntax:

number, action, jump

The position of the head is indicated by a structure \”[]\” around the cell. Example:

Initial Stage
.....[0], 0, 0, 0, 0, .....

I used the “…..” to indicate that the remnant cells are all unmarked.

So here are the Head and Tape classes:

class Cell:
”‘Class describing the cell of a tape’”

def __init__(self, mark=0):
”‘Each cell is unmarked by default’”
self.mark = mark

def setMark(self):
self.mark = 1

def remMark(self):
self.mark = 0

class Tape:
”‘Class describing the infinite reel in the machine’”

def __init__(self):
”‘Each tape has an infinite number of cells both ways’”
self.reel = []
for i in xrange(5): #we display only the required elements at a time
cell = Cell()
self.reel.append(cell)

def __str__(self):
printstr = "….."
for cell in self.reel:
printstr += str(cell.mark)+","
printstr += "….."
return printstr

class Head:
”‘Class describing the head’”

def __init__(self, tape, position=0):
self.position = position
self.tape = tape

def moveLeft(self):
if self.position != 0:
self.position -= 1

else:
extension = []
extension.append(Cell())
self.tape = extension + tape.reel

def etchMark(self):
self.tape.reel[self.position].setMark()

def remMark(self):
self.tape.reel[self.position].remMark()

def moveRight(self):
if self.position == len(self.tape.reel) – 1:
self.tape.reel.append(Cell())
self.position += 1

def getPosition(self):
return self.position

Then comes the Machine class which takes a tape as an argument. So that you can insert your own tape or use the default tape:

class Machine:
”‘Class describing the Post Machine’”

def __init__(self, tape):
self.tape = tape
self.head = Head(tape)
self.commands = {}

def parseInstruction(self, number, action, jump):
”‘Instruction is of form "[number, action, jump]"’”
self.commands[number] = [action, jump]

def beginExecution(self):
instruction = 0
action = self.commands[instruction][0]

while action != "exit":
if action == "<":
self.head.moveLeft()
elif action == ">":
self.head.moveRight()
elif action == "mark":
self.head.etchMark()
elif action == "unmark":
self.head.remMark()

print self
instruction = self.commands[instruction][1]
action = self.commands[instruction][0]

return

def __str__(self):
”‘This returns tape with the head displayed’”
a = str(self.tape)
posn = self.head.getPosition()
temp = "….."
for i in xrange(len(self.tape.reel)):
if i == posn:
temp += "["+str(self.tape.reel[i].mark)+"], "
else:
temp += str(self.tape.reel[i].mark) + ", "
temp += "….."
return temp

Next comes a function that reads an input file for instructions:

def run(input_file):
infile = open(input_file, ‘r’)
b = infile.readlines()
for instruction in b:
try:
splits = instruction.split(",")
number = int(splits[0].strip())
action = splits[1].strip()
if action == "exit":
a.parseInstruction(number, action, 0)
else:
jump = int(splits[2].strip())
a.parseInstruction(number, action, jump)
except KeyError:
return
infile.close()
a.beginExecution()

A bunch of instructions which need to be written to some file:

0, >, 2
1, <, 0
2, >, 3
3, >, 4
4, >, 5
5, mark, 6
6, >, 7
7, exit

The output:

pal-178-222:~ shriphani$ python post.py
Initial Stage
.....[0], 0, 0, 0, 0, .....
File: input_file
.....0, [0], 0, 0, 0, .....
.....0, 0, [0], 0, 0, .....
.....0, 0, 0, [0], 0, .....
.....0, 0, 0, 0, [0], .....
.....0, 0, 0, 0, [1], .....
.....0, 0, 0, 0, 1, [0], .....
pal-178-222:~ shriphani$ python post.py

The full script can be obtained at http://shriphani.com/scripts/post.py

Well, later.

RPN Calculator – Keeping Boredom Away

Shriphani — Wed, 14 Jan 2009 20:09:35 +0000

Alright, those who know me well are bound to ask, 19 credit hours and you are bored? Answer: Yes. It is still the first week and we don’t seem to have gotten beyond the “introduce your loser self to the other non-interested members of the class” and since I have only 1 programming intensive course this semester, I should have lots of time to kill.

Well, my first script this semester is an RPN calculator. Totally useless for the vast majority of people out there but they know what to expect from someone who likes theoretical computer science.

So, I first began with a stack – in this case an array. I then keep populating it with numbers and every time the state of the stack changes, it prints out the current state.

If an operation is entered (only +, -, * and /), it performs the operation, replaces the appropriate positions in the stack and then prints out the current state.

Here is the code, Its been a while since I wrote any OOP stuff in Python and the “self” especially feels weird after an entire semester of Java…

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Mail: shriphani@shriphani.com
#RPN Calculator

class Machine:
def __init__(self, stack=[]):
self.stack = []

def modifyStack(self, element):
”‘add to stack if input is float else run operation or complain’”

if self.isOperator(element):
self.operate(element)
self.printStack()
elif self.isFloat(element):
self.stack.append(element)
self.printStack()

else:
print "Only numbers and operators"

def isFloat(self, char):
”‘Checks whether the last item entered in the stack is a float or not’”
try:
float(char)
except ValueError:
return False
return True

def isOperator(self, char):
”‘Checks whether the last item entered in the stack is an operator or not’”
if char == ‘+’ or char == ‘-’ or char == ‘*’ or char == ‘/’:
return True
else:
return False

def operate(self, operator):
”‘Perform the stated operation on the last two elements in the stack’”

operand1 = float(self.stack[-1])
operand2 = float(self.stack[-2])

self.stack.pop(-1)
self.stack.pop(-1)

if operator==‘+’:
self.stack.append(operand1+operand2)

elif operator==‘-’:
self.stack.append(operand2-operand1)

elif operator==‘*’:
self.stack.append(operand1*operand2)

elif operator==‘/’:
self.stack.append(float(operand2)/float(operand1))

else:
print "God only knows what operation you have typed in"
self.stack += [operand2, operand1]
self.printStack()

def printStack(self):
print self.stack

def kickOff():
calc = Machine()
while True:
a = raw_input(‘Input: ‘)
if a != ”:
calc.modifyStack(a)
else:
calc.printStack()
raise SystemExit

print"Press Enter to Quit\n"
kickOff()

The calculator in action:

pal-179-083:~ shriphani$ python rpn.py
Press Enter to Quit

Input: 1
['1']
Input: 2
['1', '2']
Input: 3
['1', '2', '3']
Input: 4
['1', '2', '3', '4']
Input: 5
['1', '2', '3', '4', '5']
Input: +
['1', '2', '3', 9.0]
Input: h
Only numbers and operators
Input: -
['1', '2', -6.0]
Input:
['1', '2', -6.0]

In other news, I am really pissed with Picasa since I can’t see how many people have viewed my pics (http://picasaweb.google.com/shriphanip in case you are interested), I have begun filling my playlists with songs played at apple keynotes and in apple ads. Friends say this is an obsession with everything with the Apple stamp on it. I basically don’t care.

There has always been this one question bugging me since last semester. In Java:

class Test
{
public static void main(String[] args)
{
int a = 012345;
System.out.println(a);
}
}

When I run this:

pal-179-083:~ shriphani$ java Test
5349
pal-179-083:~ shriphani$

What is happening here?

Anyway, looking forward to this semester. Hope my GPA stays at 4.0

Curious Fractions

Shriphani — Fri, 14 Nov 2008 16:52:11 +0000

While suffering from conjuctivitis, fever, a sore throat and what seems to be a case of swollen tonsils determined to make nutrition a pain for the next week or two, I decided to solve a problem on Project Euler. The question I picked was Problem 33: Find all fractions with the given unorthodox cancelling method (just click the fscking link for heaven’s sake!).

I thought this problem can be solved by beginning with a base fraction and adding a numbers in the tens place to both the numerator and the denominator, then adding a number in the units place to the numerator and the denominator, adding to the units place in the numerator and the tens in the denominator and the other way round.

The code needed (in Python2.6 – just love the Fractions module there):

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Blog: http://shriphani.com/blog
#Mail: shriphani@shriphani.com

frac_list = []

from fractions import Fraction

prod = 1

def findLeft(num, den):
”‘Given a denominator, numerator pair, return the double digit possibilities by appending chars to the left’”
global prod
for i in xrange(1, 10):
if i == num or i == den:
continue
else:
if Fraction(10*i+num, 10*i+den)==Fraction(num, den):
frac_list.append(Fraction(num, den))
print num,den

def findRight(num, den):
global prod
for i in xrange(1, 10):
if i == num or i == den:
continue
else:
if Fraction(10*num+i, 10*den+i)==Fraction(num, den):
print num, den
frac_list.append(Fraction(num, den))

def findAlt(num, den):
global prod
for i in xrange(1, 10):
if i == num or i == den:
continue

elif Fraction(10*num+i, 10*i+den)==Fraction(num, den):
frac_list.append(Fraction(num, den))

elif Fraction(10*i+num, 10*den+i)==Fraction(num, den):
frac_list.append(Fraction(num, den))

for i in xrange(1, 10):
for j in xrange(1, 10):
if i==j:
continue
else:
findLeft(i, j)
findRight(i, j)
findAlt(i, j)

prod = 1
for i in xrange(len(frac_list)):
if frac_list[i] < 1/1:
prod *= frac_list[i]

print prod

BTW, it is funny how total nutjobs with no clue about probes, payloads, science or physics take up the job of reporting the Chandrayaan’s progress.

Peace…..

Awesome Developments

Shriphani — Thu, 30 Oct 2008 10:26:23 +0000

So, I’ve had the best week of my life and let me tell you folks, nothing’s better than sitting in front of one of the most awesome boxes in the world – the macbook pro. Yes, the alpha and the omega is here, I am now the proud owner of a macbook pro (not the new ones, this is the older version). So, here are the specs:

2.5 GHz

2 GB RAM (Vista was a PITA on 2 Gigs, OS X is such a beauty)

512 MB NVidia 8600M GeForce

Intel Core2Duo (obviously)

And so, here are a few select screenshots:

And of course:

And then comes:

By the way, that is how beautiful Komodo looks.

Then of course:

That is what iPhoto looks like.

BTW, between a tough courseload which does not require me to use Python, I managed to squeeze some time for myself so I could automate a few modular arithmetic algorithms.

The first one I shall be dealing with is modular exponentiation.

If we have a^k mod n, then we can express it as
(a mod n)^k mod n.

This allows us to express this in the form of code as:

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Mail: spalakod@purdue.edu
#Blog: http://shriphani.com/blog

def modular(base, exponent, divisor):
false_exponent = 0
result = 1

while false_exponent < exponent:
result = ((base%divisor)*result)%divisor
print result
false_exponent+=1

return result

Then of course comes finding the modular inverse using euclid’s algorithm:

def extended(a, b):
if a % b == 0:
return (0, 1)

else:
(x, y) = extended(b, a%b)
return (y, x-y*(a/b))

That should return a tuple whose first element is the GCD. Well, I am going to have fun with the Macbook.

Awesome Problem

Shriphani — Thu, 25 Sep 2008 00:48:39 +0000

I had the opportunity to work on an interesting problem:

Find a decent approximation for the Zeta function (large values), given by:

So, to make any sort of headway, I decided that I would have to look at the graph. Hence, I whipped up a script in Python:

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Mail: shriphani@shriphani.com
#Blog: http://shriphani.com/blog

#Generate the plot of the Zeta function.

from pylab import * #imports the matplotlib graphing library

def zetaValue(n):
”‘Returns the value of the Zeta Function n’”
val = 0
for i in range(1, n+1):
zeta_term = float(1)/float(i**2)
val += zeta_term
return val

def makePlotRange():
”‘Generates an array of form [domain_list, values_list] for 1<1000′”
num_list = [] #This contains the domains
range_list = [] #Contains value returned by Zeta function for every element in domain
for i in xrange(1,1000):
num_list.append(i)
range_list.append(zetaValue(i))
return num_list, range_list

plot_range = makePlotRange() #gets the arrays

plot(plot_range[0], plot_range[1], ‘bs’)
savefig(‘zetaplot.png’)
show()

This looks a like:

plot of the zeta function

Observe this plot. We can see that there is a horizontal asymptote at x = 1.65 .

Hence,

This leads me to conclude one bloody thing:

And,

Now, it shouldn’t come a surprise to all math or CS majors that g(x) is a function whose denominator has a higher degree than the numerator. So for the sake of simplicity, I shall assume that;

Another reason prompting my eagerness to pick that particular function is because of the following observation:

1/x is a rectangular hyperbola which looks like:
Rectangular Hyperbola
If you use -1/x , the graph is rotated about the X axis and it looks like:
Inverted Rectangular Hyperbola
So, if you look at the positive X axis, we have already managed to replicate behavior of the Zeta function. All we need to do is move it up and ensure that the limit stays.
To move this graph up, just add 1.65 to f(x) and it will work:
Inverted Rectangular Hyperbola Moved Up by 1.65
So, the limits match, the behavior matches and all we need to do is test:

I fired up Python again and wrote this code to perform the final test:

#!/usr/bin/env python
#Author: Shriphani Palakodety
#Mail: shriphani@shriphani.com
#Blog: http://shriphani.com/blog

from pylab import * #imports the matplotlib graphing library

def zetaValue(n):
”‘Returns the value of the Zeta Function n’”
val = 0
for i in range(1, n+1):
zeta_term = float(1)/float(i**2)
val += zeta_term
return val

def makePlotRange():
”‘Generates an array of form [domain_list, values_list] for 1<1000′”
num_list = [] #This contains the domains
range_list = [] #Contains value returned by Zeta function for every element in domain
for i in xrange(1,1001):
num_list.append(i)
range_list.append(zetaValue(i))
return num_list, range_list

plot_range = makePlotRange() #gets the arrays

def hypoFunction():
num_list = []
range_list = []
for i in xrange(1, 1001):
num_list.append(i)
range_list.append(float(-1)/float(i) + 1.65)
return num_list, range_list

other_range = hypoFunction()

plot(plot_range[0], plot_range[1], ‘bs’, other_range[0], other_range[1], ‘ro’)

savefig(‘zetaplot.png’)

show()

And this looks like:

A Plot of Proposed Approximation and The Zeta Function

Hey, this thing seems to replicate the behavior of the Zeta function way below x=100. Assignment done !!!!

I had another question which is coming up in the next post. I am in love with Discrete math.

Anyway, I attended this job fair thingy and got free stuff from Google, MS and others (MS was giving us ping-pong balls…). Google’s pens are serving me well. Anyway, I am sure I won’t be accepted as an intern anywhere thanks to the fact that every company thinks that freshmen are losers and don’t deserve to be emloyed right in their first year.

Anyway, keep waiting for the second approximation I did.