Algorithms on traviscj/blog

profitably wrong

Tue, 09 Jan 2018 08:00:00 +0000

I’ve come to realize that my career so far has been built on being “profitably wrong.” I think this is interesting because the usual approaches are being “profitably fast” (optimizing) or “profitably better” (improving), and most people think of any kind of wrongness as being a terrible thing. But sometimes the best way to optimize or improve is approximating!

The definitions of “profitably” has changed as I’ve worked on different things, as has the specific type of “wrongness”. A couple specific ways accepting “wrongness” have been profitable for me include:

snack buying

Mon, 13 Nov 2017 07:01:25 +0000

I got this text message from my father-in-law:

Ok. Soda 1.50 Chocolate bar 1.00 Gum 0.10 Jelly Bean .05

Have to buy exactly 14 items and spend $10

At least one of each.

There are 4 diff combos. (Order: soda, chocolate, gum and jelly bean)

Got 5-2-3-4 3-5-4-2

Can’t get others. Any ideas? :)

I whipped up this solution to check in python:

#!/usr/bin/python3
# created_at: 2017-11-13 13:53:19 -0800

def main():
    solutions = 0
    for si in range(1,7):
        for ci in range(1,11):
            for gi in range(1,101):
                for ji in range(1,201):
                    total = si*150 + ci*100 + gi*10 + ji*5
                    items = si + ci + gi + ji
                    if total == 1000 and items == 14:
                        print(si,ci,gi,ji, total, items)
                        solutions += 1
    print(solutions)

if __name__ == "__main__":
    main()

The core of this solution is the check

black box machine learning

Tue, 15 Jul 2014 00:00:00 +0000

During my Ph.D. I studied optimization algorithms. Optimization algorithms are typically an integral part of machine learning algorithms, and we discussed many machine learning algorithms, but somehow I made it through without doing very much actual machine learning training or prediction tasks.

It turns out that it isn’t very hard to do some very basic machine learning:

pip install -U numpy scipy scikit-learn
ipython
from sklearn.ensemble import RandomForestClassifier
from sklearn import datasets
iris_data = datasets.load_iris()
rfc = RandomForestClassifier()
rfc.fit(iris_data['data'], iris_data['target'])
rfc.predict([6.1,2.6,5.6,1.4])    # yields array([2])
rfc.predict([5.7,4.4,1.5,0.4])    # yields array([0])

a really simple iterative refinement example

Thu, 17 Oct 2013 00:00:00 +0000

I wanted to have a quick example of what iterative refinement is and looks like.

Suppose you wanted to solve the (very simple!) problem of solving 5.1x=16, without dividing by decimal numbers. (Yes, this is a bit contrived–I’m not sure why you would be able to divide by an integer to get a decimal, but not divide by a decimal to get a decimal. Bear with me.)

The standard way would be, of course, to simply evaluate x = (5.1)^{-1}16=3.137254. But this is not available–you can’t find an inverse of multiplying by 5.1!

implementation of set operations

Wed, 13 Mar 2013 00:00:00 +0000

We got in a bit of a debate yesterday in the office over the implementation of associative containers, which I thought was pretty fun. We made up the big chart of complexity results you see below.

nomenclature:

$S$, $S_1$, and $S_2$ are subsets of $\Omega$.
Denote an element by $e\in\Omega$.
$n$,$n_1$,$n_2$,$N$ are the sizes of the set $S$, $S_1$, $S_2$, and $\Omega$, respectively, and $n_1 \geq n_2$.

Complexity

Operation\Approach	Hash Table	Hash Tree	Binary List	Entry List (sorted)	Entry List (unsorted)
$e \in S $	$O(1) $	$O(log(n)) $	$O(1) $	$O(log(n)) $	$O(n) $
$S_1 \cup S_2 $	$O(n_1+n_2) $	$O(n_1+n_2) $	$O(N) $	$O(n_1+n_2) $	$O(n_1n_2) $
$S_1 \cap S_2 $	$O(n_1) $	$O(log(n_1)n_2)$	$O(N) $	$O(n_2) $	$O(n_1n_2) $
space complexity	$O(n) $	$O(n) $	$O(N)$ bits.	$O(n) $	$O(n) $

As I said–this was just what came out of my memory of an informal discussion, so I make no guarantees that any of it is correct. Let me know if you spot something wrong! We used the examples $S_1 = {1,2,3,4,5}$ and $S_2 = {500000}$ to think through some things.

some tips for project euler problems

Sat, 26 Jan 2013 00:00:00 +0000

I wanted to make a list of a few tips on solving Project Euler problems that have been helpful for me while I solve them. These are general principles, even though I do most of my Project Euler coding in Python.

Without further ado:

If the problem is asking for something concerning the number of digits, typically this indicates that the use of the $\log n$ function is warranted.
If the problem is asking for the last few digits, modulo arithmetic might speed it up considerably.
Some might consider this cheating, but looking up some small numbers in the Online Encyclopedia of Integer Sequences is occasionally pretty helpful.
Many problems boil down to: Find numbers with property $X$ and property $Y$. Two solutions are:
- Brute force: Try all numbers with tests of property $X$ and $Y$.
- Find numbers with property $X$ and filter by a test of property $Y$.
- Find numbers with property $Y$ and filter by a test of property $X$.
- Find the set of numbers with property $X$ and the set of numbers with property $Y$. Compute their intersection.

I’ve found that it’s sometimes hard to predict which one will end up being the fastest. It depends on the relative speed of the tests and the generators, and the frequency of finding numbers which have that property.

Game of Life

Tue, 20 Nov 2012 00:00:00 +0000

When I was a sophomore in high school, I was fascinated with [ Conway’s Game of Life]. I still am. I did a pretty rudamentary study of the kinds of patterns that could form from the simple rules of the game.

One thing that wasn’t available when I was a sophomore was Youtube. Two of my favorite Game of Life videos:

Another direction that Game of Life has gone recently is something that I really should have thought of, honestly. Many times I’ve thought that there’s at least some superficial relationship between Game of Life and diffusion equations. Turns out that S. Rafler has extended Game of Life to continuous domains through what he calls SmoothLife.

a trig problem solved in MATLAB

Wed, 01 Feb 2012 00:00:00 +0000

I came across this post. The basic idea is the guy wants to maximize $L_1+L_2$ constrained to this box, where $L_i$ is the length of beam $i$. It’s constrained to be a 61 cmx61 cm box, but one beam must start from 10cm up from the bottom right corner and the beams must meet at a point along the top of the box. I added the further assumption that the other beam must end in the bottom left corner.

spamfunc for optimization in matlab

Mon, 30 Jan 2012 00:00:00 +0000

what spamfunc is

In developing optimization algorithms, one of the most tedious parts is trying different examples, each of which might have its own starting points or upper or lower bounds or other information. The tedium really starts when your algorithm requires first or second order information, which might be tricky to calculate correctly. These bugs can be pernicious, because it might be difficult to differentiate between a bug in your algorithm and a bug in your objective or constraint evaluation. Handily, Northwestern Professor Robert Fourer wrote a language called AMPL, which takes a programming-language specification of objective and constraints and calculates derivatives as needed. The official amplfunc/spamfunc reference is contained in Hooking Your Solver to AMPL, but I’m shooting for a more low-key introduction.

What could you possibly do with mathematics?

Mon, 24 Aug 2009 00:00:00 +0000

Recently, at a family gathering, I was confronted by the question many a college graduate is faced after telling someone I had majored in mathematics for my now-finished college degree: “But how are you going to make any money at that?”

Now, certainly it’s true: Graduate students don’t make that much. The average stipend for a grad student is roughly on par with (but still less than) unemployment checks. But that’s okay–in general, mathematicians know that they could make money other places, but they chose it anyways because of their love for the subject. Not that mathematicians make too bad of money anyway: The average in the US is about 50K, with associate professors making more than that. The particularly salary-inclined could pick up other credentials to become actuaries or work in hedge funds.

Dijkstra's Algorithm Paper

Wed, 30 Jul 2008 00:00:00 +0000

The week before my sister’s wedding, I was tasked with writing a paper on Dijkstra’s Algorithm for my Discrete Mathematical Modeling class. I think I might have missed the mark a little bit, but I had so much fun writing it that I’m posting it here.

I’m almost considering writing some more stuff in this style… anything anyone would like to see written about?

Here’s a link: Dijkstra’s Algorithm