Paul Bergeron

Setting Up Disco - A JVM-free Alternative To Hadoop

2014-04-19T22:46:00+02:00

The Disco Project is a re-implmentation of MapReduce, but instead of using the JVM and the Hadoop Ecosystem, Disco takes a different approach. Instead, Disco uses a unique hybrid of Python and Erlang. This intrigues me because this brings Python based tools like Scikit-learn and NumPy to a MapReduce framework.

Disco also has it’s own merits that allow it to stand toe-to-toe with it’s much more widely known and slightly older brother Hadoop. All the standard facilities are here, a distributed file system (DDFS), a task tracker of sorts, but without the verbrositiy of the JVM, and also, a much more streamlined setup process.

I hit a couple of snags following the guide in the documentation, which is why I decided to write this post. However, this step by step will largely echo the guide, but be targeted towards getting a local development install up and running. Also, this is for OS X systems only, so we’ll be using homebrew for package installs.

First, grab some dependancies.

brew install python erlang lighttpd varnish

Make sure you have a local SSH server running as well. Thankfully, OS X comes with one, make sure you have it running by double checking System Preferences, Sharing, and making sure the Remote Login service is enabled.

Verify that your SSH key is also configured correctly and is working by doing ssh localhost and making sure you aren’t asked for a password.

If that succeeds without prompting for a password, then you should proceed. Setting up SSH keys can get pretty tricky and there are already a lot of guides out there for that, so I’ll skip over it. If you need help, try here.

Add the following to your ~/bash_profile, and source ~/bash_profile or restart your shell.

export DISCO_HOME=/Users/$USER/disco
export PATH=$PATH:$DISCO_HOME/bin

Here are the commands to download and build Disco in a way that works well for development and local testing, with homebrew’s packages. This also installs the master branch, which is considered stable for production. The newer branch develop does work, and has a lot of improvements, but there’s a larger chance of hitting a bug.

cd ~/
git clone git://github.com/discoproject/disco.git $DISCO_HOME
cd $DISCO_HOME
git checkout master # Skip this step to live on the edge
make
cd lib && python setup.py install && cd ..

If you followed all the steps correctly, disco nodaemon should start disco without error.

In another shell, running python $DISCO_HOME/examples/util/count_words.py will confirm your setup by running the class of all MapReduce jobs, the Word Count.

That’s it, you’re all setup, happy hacking on Disco!

From Zero To Om

2014-01-08T20:24:00+01:00

Om by swannodette is a ClojureScript interface to Facebook’s React. It’s power is that it can create UIs that are easily snapshottable, rewindable, and all with great performance.

Getting to a good starting point with ClojureScript can be a little complicated, so here’s a step-by-step process for going from a clean slate to a working development enviroment.

Presuming leiningen installed, getting a ClojureScript app template is easy.

Just use mihneadb’s ClojureScript template.

lein new cljs-webapp PROJECT-NAME
cd PROJECT-NAME

Add Om to the dependencies in project.clj

...
  :dependencies [[org.clojure/clojure "1.5.1"]
                 [org.clojure/clojurescript "0.0-2138"]
                 [om "0.1.5"]]
...

Then edit resources/public/index.html and add a div, and React to the element:

...
  
   id="some-id">
  
...

Now, time for some ClojureScript, edit core.cljs

(ns project-name.core
  (:require [om.core :as om :include-macros true]
            [om.dom :as dom :include-macros true]))

(defn widget [data owner]
  (om/component
    (dom/div nil "Hello world!")))

(om/root {} widget (.getElementById js/document "some-id"))

Last step, let’s get it on the browser:

lein cljsbuild once dev
ruby -run -ehttpd resources/public -p8080 # Just hosts the current path on the given port

Then just open http://localhost:8080/ in your browser, and you’ve got a working Om ClojureScript app running!

Event Machine In Normal Ruby (or Rails) Apps

2013-05-28T19:40:00+02:00

I learned a new trick from my friend and co-worker @DaDDYe, author of the awesome Padrino framework, on how to use EventMachine in normal Ruby or Rails applications.

In most EventMachine apps, you have to place everything inside of a EventMachine.run block, i.e.:

require 'eventmachine'

EM.run do
  # ... your app here
end

This usually means that concurrent Ruby apps have to be designed so from the start. However, you can get around this limitation.

You can start EventMachine in a seperate thread, and then you can use EventMachine calls in your synchronous program. There’s some setup and teardown to make sure everything works:

eventmachine_threads.rb

require 'eventmachine'

# Setup EventMachine
Thread.new { EM.run  }

# Catch signals to ensure a clean shutdown of EventMachine
trap(:INT) { EM.stop }
trap(:TERM){ EM.stop }

# Wait for the reactor to start
while not EM.reactor_running?; end

# Setup done! Now you can use any EventMachine code here!

# Examples:
channel = EM::Channel.new
sub_id  = channel.subscribe { |msg| puts "Got: #{msg}" }

channel.push('hello world')
# => "Got: hello world"

# Clean up channel
channel.unsubscribe(sub_id)

# Will output the current time every second since it started
EM.add_timer(1) { puts "Executing timer: #{Time.now}" }

# Deferred blocks execute concurrently to the main thread
EM.defer { sleep 3; puts "It's been at least 3 seconds!" }

# Can even use EventMachine modules and code for async I/O
EM.system('ls') { |output,status| puts output }

# Tear-down, make sure that all EM defers finish
while not EM.defers_finished?; end

There’s some obvious advantages to doing this, you can easily bring asynchronous I/O and concurrent processing to any Ruby program, even in normal Rails code. There is a cost, however, and that comes in performance:

bench_results.rb

# Rehearsal -------------------------------------------------------
# normal EventMachine   0.180000   0.000000   0.180000 (  0.185271)
# ---------------------------------------------- total: 0.180000sec

#                           user     system      total        real
# normal EventMachine   0.170000   0.000000   0.170000 (  0.173966)

# Rehearsal ---------------------------------------------------------
# threaded EventMachine   0.450000   0.730000   1.180000 (  0.806186)
# ------------------------------------------------ total: 1.180000sec

#                             user     system      total        real
# threaded EventMachine   0.740000   1.390000   2.130000 (  1.384526)

Using the threaded approach is a large performance penalty, but the trade off is the additional flexibility. Use it wisely.

Benchmark code for normal EventMachine:

eventmachine_bench.rb

require 'eventmachine'
require 'benchmark'

EM.run do
  channel = EM::Channel.new
  counter = 0
  sub_id  = channel.subscribe { |msg| counter += msg }

  Benchmark.bmbm do |x|
    x.report("normal EventMachine") { 50000.times {|i| channel.push(i) } }
  end
end

Benchmark code for the threaded EventMachine:

eventmachine_thread_bench.rb

require 'eventmachine'
require 'benchmark'

Thread.new { EM.run  }

# Catch signals to ensure a clean shutdown of EventMachine
trap(:INT) { EM.stop }
trap(:TERM){ EM.stop }

# Wait for the reactor to start
while not EM.reactor_running?; end

channel = EventMachine::Channel.new
counter = 0
sub_id  = channel.subscribe { |msg| counter += msg }

Benchmark.bmbm do |x|
  x.report("threaded EventMachine") { 50000.times {|i| channel.push(i) } }
end

Streaming Youtube to MP3 Audio in NodeJS

2011-12-28T00:00:00+01:00

Recently I learned how to stream a Youtube video’s audio in MP3 format using nodejs. I wanted to publish my findings and show off how to accomplish this.

First, let’s build this the non streaming way, and then I will show you how to upgrade to a streaming method. You must install the powerful ffmpeg via your package management system of choice in order to play along.

I’ll be using nodejs, to do this, because it offers us a very easy way to stream bits around. Despite the recent controversy, I’m still quite partial to coffee-script due to it’s terse syntax and clean output, so I’m going to use that for most of the new code. Let’s also use the wonderful expressjs framework to get us started really quickly. This will set up our project skeleton.

express youtube_audio_streamer
cd youtube_audio_streamer && npm install

You can now convert the skeleton into coffee-script if you like, but I leave this as an exercise to the reader. For the sake of time I simply spawn another shell and do the following in it:

mkdir routes/coffee
cat > routes/coffee/index.coffee <
exports.index = (req, res) ->
res.render('index', { title: 'Express' })
SCRIPT
coffee -c -w -o routes routes/coffee/*

Then in yet another shell we can:

node app.js

And we’re rocking the “hello world!” page.

Now, we have to add another dependancy to the project. It turns out that getting a good, uncompressed FLV that ffmpeg can digest into something we can use is a giant pain. There’s cookies that need setting, HTML that needs parsing, and language detection to accomplish. Luckily for us, misery loves company and the hard work of turning a normal youtube video url ( http://www.youtube.com/watch?v=:youtube_video_id ) into a ffmpeg edible FLV can be done by youtube-dl. Requires python, but otherwise dependancy free. This means that we can focus on building something quickly. Assuming you’ve got a sane python accessible on your system, install it to the root of the project like so:

curl -s -o youtube-dl https://raw.github.com/rg3/youtube-dl/2011.12.18/youtube-dl &&
chmod +x youtube-dl

Let’s use it from the command line and see what how it works. I’ve plucked a random short video clip that’s holiday themed for the demonstration. Remember, we just want the audio, and we want it in MP3.

./youtube-dl --extract-audio --audio-format mp3
http://www.youtube.com/watch](http://www.youtube.com/watch)\?v\=mayCvk2P4f0
[youtube] Setting language
[youtube] mayCvk2P4f0: Downloading video webpage
[youtube] mayCvk2P4f0: Downloading video info webpage
[youtube] mayCvk2P4f0: Extracting video information
[download] Destination: mayCvk2P4f0.flv
[download] 100.0% of 124.19k at  988.27k/s ETA 00:00
[ffmpeg] Destination: mayCvk2P4f0.mp3

Playing the resulting mayCvk2P4f0.mp3 results in Arnald’s voice demanding us to release the cookie. Excellent! Let’s make an API for this!

The only variable in all of this is the alphanumeric video id at end of the youtube video URL. I’m going to call this the :youtube_video_id from now on. Since we’ll be using a child process to launch youtube-dl, and we’re going to need to write the resulant file back to the browser, we’ll need the native nodejs modules ‘child_process’ and ‘fs’. Knowing this, let’s add the following code to routes/coffee/index.coffee

exports.youtube_mp3 = (req, res) ->
  # Spawn a child process to obtain FLV and use ffmpeg to convert it.
  youtube_dl = spawn './youtube-dl', ['--extract-audio', '--audio-format', 'mp3', "http://www.youtube.com/watch?v=#{req.params.youtube_video_id}"]

  # Let's echo the output of the child to see what's going on
  youtube_dl.stdout.on 'data', (data) ->
    console.log data.toString()
    # Incase something bad happens, we should write that out too.
    youtube_dl.stderr.on 'data', (data) ->
      process.stderr.write data
      # when we're done, let's send back the output
    youtube_dl.on 'exit', ->
      readFile "./#{req.params.youtube_video_id}.mp3", (err, data) ->
      # We set our content type so consumers of our API know what they are getting
      res.send data, { 'Content-Type': 'audio/mpeg3' }

Let’s add this to our routes in app.js with this line:

app.get('/youtube_mp3/:youtube_video_id', routes.youtube_mp3);

Now restart our development server and go to http://localhost:3000/youtube_mp3/mayCvk2P4f0 to see the following in the log. It will probably differ slightly, and as you can see, the internet connection I’m on is terribly slow. If you have something in your browser capable of playing mp3’s, you should hear audio.

Express server listening on port 3000 in development mode
[youtube] Setting language
[youtube] mayCvk2P4f0: Downloading video webpage
[youtube] mayCvk2P4f0: Downloading video info webpage
[youtube] mayCvk2P4f0: Extracting video information
[download] Destination: mayCvk2P4f0.flv
[download]  5.6% of 124.19k at  93.16k/s ETA 00:01
[download]  12.1% of 124.19k at  195.03k/s ETA 00:00
[download]  25.0% of 124.19k at  201.17k/s ETA 00:00
[download]  50.7% of 124.19k at  387.09k/s ETA 00:00
[download] 100.0% of 124.19k at  530.81k/s ETA 00:00
[ffmpeg] Destination: mayCvk2P4f0.mp3

So, what just happened? We take the id of a video, and feed it to youtube-dl, which finds us an appropriate FLV file. This is then fed into ffmpeg, which outputs this to a static mp3 file, which we then open and read. We should probably upgrade this to cleanly delete the mp3 when it’s done, but it will be better to do this as streaming instead, then not only will we have no intermediary file to worry about, it will be a better user experiance.

To see what I mean about a better user experiance, instead of using a short video, let’s try a long one. I’m going to demonstrate this with a 8:44 long video of New Years 2011 in Times Square, . Go to http://localhost:3000/youtube_mp3/GKpRXswgDwU. If you have a fast internet connection, this video may download fully and play before your browser times out, but I doubt you’ll be impressed with the performance of our first attempted solution. I won’t paste the log here, but you’ll see the video is ~133mb! Way too much data to download all at once and expect reasonable performance. Now, youtube-dl has some options about setting the max quality and since it defaults to the highest availible we could probably do well to turn that down. In fact, if you do end up using this code in production, I would suggest you do that anyway if only to lower the bandwidth bill.

In order to make this work with larger videos, we can’t just download the whole video up front. We need to be able to simultaneously stream the video from youtube into ffmpeg, and the output of ffmpeg, directly into the response.

Let’s step away from the code and get something working in the shell first. To solve the first problem of streaming the FLV into ffmpeg, we can get ffmpeg to take input from stdin, and use a unix pipe to stream in the data outputed from GET’ing the URL of the FLV. We’re going to need to get the URL that’s used internally by youtube-dl. Luck us, there’s a combination of options that outputs this for us in ./youtube-dl --help. Here’s the incantation to get the FLV from a youtube video URL without downloading any video:

./youtube-dl --simulate --get-url http://www.youtube.com/watch\?v\=:youtube_video_id

Now with the URL, we can write the new streaming code by first retriveing that URL by using a youtube-dl child process. Then we can GET the FLV, as we recieve the file from youtube, we can pipe the data directly into a ffmpeg subprocess. With ffmpeg set to output the data on stdout, we can pipe this data directly to the response.

The two subprocess streaming to response setup can be done using pure nodejs, but why do that when we have the excellent request library at our disposal. As you will see, this library makes the code a lot shorter and easier to read. Add this as a dependancy to the project in the package.json file, and then npm install it.Once that’s done, let’s replace the whole file of routes/coffee/index.coffee with this:

{spawn, exec} = require 'child_process'

request = require 'request'

exports.index = (req, res) ->
  res.render('index', { title: 'Express' })

  exports.youtube_mp3 = (req, res) ->
  # Spawn a child process to obtain the URL to the FLV
  youtube_dl_url_child = exec "./youtube-dl --simulate --get-url http://www.youtube.com/watch?v=#{req.params.youtube_video_id}", (err, stdout, stderr) ->
    # Converting the buffer to a string is a little costly so let's do it upfront
    youtube_dl_url = stdout.toString()
    # there's a trailing '\n' returned from youtube-dl, let's cut it off
    youtube_dl_url = youtube_dl_url.substring(0, youtube_dl_url.length-1)
    # Before we write the output, ensure that we're sending it back with the proper content type
    res.contentType = 'audio/mpeg3'
    # Create an ffmpeg process to feed the video to.
    ffmpeg_child = spawn "ffmpeg", ['-i', 'pipe:0', '-acodec', 'libmp3lame','-f', 'mp3', '-']
    # Setting up the output pipe before we set up the input pipe ensures wedon't loose any data.
    ffmpeg_child.stdout.pipe(res)
    # GET the FLV, pipe the response's body to our ffmpeg process.
    request({url: youtube_dl_url, headers: {'Youtubedl-no-compression':'True'}}).pipe(ffmpeg_child.stdin)

There are a couple of bits of “magic” that need to be covered in the above code. Digging around in the source of youtube-dl, you’ll see the request to get the FLV has the header ‘Youtubedl-no-compression’ set to ‘True’. I mimic this behavior in order to ensure ffmpeg get’s uncompressed FLV data from youtube, as ffmpeg does not support compressed FLVs. A possible upgrade later is to dechipher the FLV compression and decompress this on the fly to ffmpeg, so we can use less bandwidth downloading the video. The other bit of magic are the command line args we’re passing to ffmpeg. They are a combination of the same args used by youtube-dl to produce an mp3, as well as telling ffmpeg to take data in from stdin (the ‘-i’, and ‘pipe:0’) and output to stdout (the ‘–’) We’re also using LAME to re-encode the audio to mp3, you may need to adjust this to an encoder availible on your system, or install LAME if it isn’t installed.

A few other comments, I dropped the dependency on ‘fs’ as we aren’t reading a file anymore, and I use ‘child_process.exec’ for getting the URL, as the output is short and we fully depend on the completion of this process before moving on. I use ‘child_process.spawn’ for creating the ffmpeg child process because it allows access to the stdin and stdout streams. There’s also lots of things that can go wrong that I’m not checking for, but this is a proof of concept code sample anyway, so use at your own risk.

After restarting your development server, go to http://localhost:3000/youtube_mp3/GKpRXswgDwU. What once either timed out or sat for a long time no longer does! Provided everything went OK, we get the expected behavior of streaming the audio through the whole process.

A note about scaling: this setup would be expensive to scale due to the re- encoding which is CPU bound, and with the code above you’re limited to a single machine. To scale this further, I would useZeroMQ. On each request for a youtube video to be encoded as audio, use a ZMQ_PUSH socket to give a FLV URL worker a :youtube_video_id to lookup to a FLV URL. This worker could then ZMQ_PUSH to another set of workers that download the FLV and re-encode the audio to mp3, while publishing with ZMQ_PUB a response_id and a chunk of data to write to it. This setup will scale horizontally very well, additional horsepower can be added very easily to the re-encoding layer. Alternate scaling plans could be to use Ha-Proxy to round-robin the full HTTP requests to different machines running the code here, but this would need to be separate from the rest of the web application’s code.

I hope that the exercise was as educational for you as it was for me. Some other things to think about, how do we enchance this to accept “Range” requests so we can use the streamed audio with jPlayer? We’ll need to have better error handling to use this in production, where are some good places to add error handling and what’s worthwhile to validate? Is there anyway we can decompress the FLVs on the fly and then stream this output to ffmpeg, to save bandwidth? What’s a good caching strategy for looking up the URLs of the FLVs from youtube? Is it worthwhile to move the URL retrieval process into JS so we can do this in nodejs?

Fixed Point Math in C#

2009-07-01T00:00:00+02:00

Fixed point math is an interesting optimization for games, and it also has the feature of determinism, something that floating point implementations lack due to rounding, truncation, and hardware differences.

With determinism, a networked physics simulation can guarantee that every machine can perform the same action, and given the exact same starting conditions, produce the same result. This reduces the network overhead significantly, instead of being forced to check the same result was achieved across all computers participating, one can instead make sure that each action was completed in the correct order instead.

Of course, cheating may force checks on the results anyway, but that’s a different problem.

(FInt.cs) download

/*
Fixed Point Arithmatic structure and relevant methods. Simple fixed point structure included as well.

Created from information and code gathered here: http://stackoverflow.com/questions/605124/fixed-point-math-in-c

May be used for anything without permission.

To quote the original author (x4000 of stackoverflow.com):
"The accuracy of these functions as they are coded here is more than enough for my purposes, but if you need more you can increase the SHIFT AMOUNT on FInt.
Just be aware that if you do so, the constants on [trigonomic] functions will then need to be divided by 4096 and then multiplied by whatever your new SHIFT AMOUNT requires.
You're likely to run into some bugs if you do that and aren't careful, so be sure to run checks against the built-in Math functions to make sure that your results aren't
being put off by incorrectly adjusting a constant."

Code credit: x4000 of stackoverflow.com

Compiled into a usable source file by: Paul Bergeron

Date: 7/1/2009

More fixed point functions can be found written in Java here: http://home.comcast.net/~ohommes/MathFP/

*/

public struct FInt
{
    public long RawValue;
    public const int SHIFT_AMOUNT = 12; //12 is 4096

    public const long One = 1 << SHIFT_AMOUNT;
    public const int OneI = 1 << SHIFT_AMOUNT;
    public static FInt OneF = new FInt( 1, true );

    #region Constructors
    public FInt( long StartingRawValue, bool UseMultiple )
    {
        this.RawValue = StartingRawValue;
        if ( UseMultiple )
            this.RawValue = this.RawValue << SHIFT_AMOUNT;
    }
    public FInt( double DoubleValue )
    {
        DoubleValue *= (double)One;
        this.RawValue = (int)Math.Round( DoubleValue );
    }
    #endregion

    public int IntValue
    {
        get { return (int)( this.RawValue >> SHIFT_AMOUNT ); }
    }

    public int ToInt()
    {
        return (int)( this.RawValue >> SHIFT_AMOUNT );
    }

    public double ToDouble()
    {
        return (double)this.RawValue / (double)One;
    }

    public FInt Inverse
    {
        get { return new FInt( -this.RawValue, false ); }
    }

    #region FromParts
    /// 
    /// Create a fixed-int number from parts.  For example, to create 1.5 pass in 1 and 500.
    /// 
    /// The number above the decimal.  For 1.5, this would be 1.
    /// The number below the decimal, to three digits.
    /// For 1.5, this would be 500. For 1.005, this would be 5.
    /// A fixed-int representation of the number parts
    public static FInt FromParts( int PreDecimal, int PostDecimal )
    {
        FInt f = new FInt( PreDecimal );
        if ( PostDecimal != 0 )
            f.RawValue += ( new FInt( PostDecimal ) / 1000 ).RawValue;

        return f;
    }
    #endregion

    #region *
    public static FInt operator *( FInt one, FInt other )
    {
        return new FInt( ( one.RawValue * other.RawValue ) >> SHIFT_AMOUNT, false );
    }

    public static FInt operator *( FInt one, int multi )
    {
        return one * (FInt)multi;
    }

    public static FInt operator *( int multi, FInt one )
    {
        return one * (FInt)multi;
    }
    #endregion

    #region /
    public static FInt operator /( FInt one, FInt other )
    {
        return new FInt( ( one.RawValue << SHIFT_AMOUNT ) / ( other.RawValue  ), false );
    }

    public static FInt operator /( FInt one, int divisor )
    {
        return one / (FInt)divisor;
    }

    public static FInt operator /( int divisor, FInt one )
    {
        return (FInt)divisor / one;
    }
    #endregion

    #region %
    public static FInt operator %( FInt one, FInt other )
    {
        return new FInt( ( one.RawValue ) % ( other.RawValue ), false );
    }

    public static FInt operator %( FInt one, int divisor )
    {
        return one % (FInt)divisor;
    }

    public static FInt operator %( int divisor, FInt one )
    {
        return (FInt)divisor % one;
    }
    #endregion

    #region +
    public static FInt operator +( FInt one, FInt other )
    {
        return new FInt( one.RawValue + other.RawValue, false );
    }

    public static FInt operator +( FInt one, int other )
    {
        return one + (FInt)other;
    }

    public static FInt operator +( int other, FInt one )
    {
        return one + (FInt)other;
    }
    #endregion

    #region -
    public static FInt operator -( FInt one, FInt other )
    {
        return new FInt( one.RawValue - other.RawValue, false );
    }

    public static FInt operator -( FInt one, int other )
    {
        return one - (FInt)other;
    }

    public static FInt operator -( int other, FInt one )
    {
        return (FInt)other - one;
    }
    #endregion

    #region ==
    public static bool operator ==( FInt one, FInt other )
    {
        return one.RawValue == other.RawValue;
    }

    public static bool operator ==( FInt one, int other )
    {
        return one == (FInt)other;
    }

    public static bool operator ==( int other, FInt one )
    {
        return (FInt)other == one;
    }
    #endregion

    #region !=
    public static bool operator !=( FInt one, FInt other )
    {
        return one.RawValue != other.RawValue;
    }

    public static bool operator !=( FInt one, int other )
    {
        return one != (FInt)other;
    }

    public static bool operator !=( int other, FInt one )
    {
        return (FInt)other != one;
    }
    #endregion

    #region >=
    public static bool operator >=( FInt one, FInt other )
    {
        return one.RawValue >= other.RawValue;
    }

    public static bool operator >=( FInt one, int other )
    {
        return one >= (FInt)other;
    }

    public static bool operator >=( int other, FInt one )
    {
        return (FInt)other >= one;
    }
    #endregion

    #region <=
    public static bool operator <=( FInt one, FInt other )
    {
        return one.RawValue <= other.RawValue;
    }

    public static bool operator <=( FInt one, int other )
    {
        return one <= (FInt)other;
    }

    public static bool operator <=( int other, FInt one )
    {
        return (FInt)other <= one;
    }
    #endregion

    #region >
    public static bool operator >( FInt one, FInt other )
    {
        return one.RawValue > other.RawValue;
    }

    public static bool operator >( FInt one, int other )
    {
        return one > (FInt)other;
    }

    public static bool operator >( int other, FInt one )
    {
        return (FInt)other > one;
    }
    #endregion

    #region <
    public static bool operator <( FInt one, FInt other )
    {
        return one.RawValue < other.RawValue;
    }

    public static bool operator <( FInt one, int other )
    {
        return one < (FInt)other;
    }

    public static bool operator <( int other, FInt one )
    {
        return (FInt)other < one;
    }
    #endregion

    public static explicit operator int( FInt src )
    {
        return (int)( src.RawValue >> SHIFT_AMOUNT );
    }

    public static explicit operator FInt( int src )
    {
        return new FInt( src, true );
    }

    public static explicit operator FInt( long src )
    {
        return new FInt( src, true );
    }

    public static explicit operator FInt( ulong src )
    {
        return new FInt( (long)src, true );
    }

    public static FInt operator <<( FInt one, int Amount )
    {
        return new FInt( one.RawValue << Amount, false );
    }

    public static FInt operator >>( FInt one, int Amount )
    {
        return new FInt( one.RawValue >> Amount, false );
    }

    public override bool Equals( object obj )
    {
        if ( obj is FInt )
            return ( (FInt)obj ).RawValue == this.RawValue;
        else
            return false;
    }

    public override int GetHashCode()
    {
        return RawValue.GetHashCode();
    }

    public override string ToString()
    {
        return this.RawValue.ToString();
    }

    #region PI, DoublePI
    public static FInt PI = new FInt( 12868, false ); //PI x 2^12
    public static FInt TwoPIF = PI * 2; //radian equivalent of 260 degrees
    public static FInt PIOver180F = PI / (FInt)180; //PI / 180
    #endregion

    #region Sqrt
    public static FInt Sqrt( FInt f, int NumberOfIterations )
    {
        if ( f.RawValue < 0 ) //NaN in Math.Sqrt
            throw new ArithmeticException( "Input Error" );
        if ( f.RawValue == 0 )
            return (FInt)0;
        FInt k = f + FInt.OneF >> 1;
        for ( int i = 0; i < NumberOfIterations; i++ )
            k = ( k + ( f / k ) ) >> 1;

        if ( k.RawValue < 0 )
            throw new ArithmeticException( "Overflow" );
        else
            return k;
    }

    public static FInt Sqrt( FInt f )
    {
        byte numberOfIterations = 8;
        if ( f.RawValue > 0x64000 )
            numberOfIterations = 12;
        if ( f.RawValue > 0x3e8000 )
            numberOfIterations = 16;
        return Sqrt( f, numberOfIterations );
    }
    #endregion

    #region Sin
    public static FInt Sin( FInt i )
    {
        FInt j = (FInt)0;
        for ( ; i < 0; i += new FInt( 25736, false ) ) ;
        if ( i > new FInt( 25736, false ) )
            i %= new FInt( 25736, false );
        FInt k = ( i * new FInt( 10, false ) ) / new FInt( 714, false );
        if ( i != 0 && i != new FInt( 6434, false ) && i != new FInt( 12868, false ) &&
            i != new FInt( 19302, false ) && i != new FInt( 25736, false ) )
            j = ( i * new FInt( 100, false ) ) / new FInt( 714, false ) - k * new FInt( 10, false );
        if ( k <= new FInt( 90, false ) )
            return sin_lookup( k, j );
        if ( k <= new FInt( 180, false ) )
            return sin_lookup( new FInt( 180, false ) - k, j );
        if ( k <= new FInt( 270, false ) )
            return sin_lookup( k - new FInt( 180, false ), j ).Inverse;
        else
            return sin_lookup( new FInt( 360, false ) - k, j ).Inverse;
    }

    private static FInt sin_lookup( FInt i, FInt j )
    {
        if ( j > 0 && j < new FInt( 10, false ) && i < new FInt( 90, false ) )
            return new FInt( SIN_TABLE[i.RawValue], false ) +
                ( ( new FInt( SIN_TABLE[i.RawValue + 1], false ) - new FInt( SIN_TABLE[i.RawValue], false ) ) /
                new FInt( 10, false ) ) * j;
        else
            return new FInt( SIN_TABLE[i.RawValue], false );
    }

    private static int[] SIN_TABLE = {
        0, 71, 142, 214, 285, 357, 428, 499, 570, 641,
        711, 781, 851, 921, 990, 1060, 1128, 1197, 1265, 1333,
        1400, 1468, 1534, 1600, 1665, 1730, 1795, 1859, 1922, 1985,
        2048, 2109, 2170, 2230, 2290, 2349, 2407, 2464, 2521, 2577,
        2632, 2686, 2740, 2793, 2845, 2896, 2946, 2995, 3043, 3091,
        3137, 3183, 3227, 3271, 3313, 3355, 3395, 3434, 3473, 3510,
        3547, 3582, 3616, 3649, 3681, 3712, 3741, 3770, 3797, 3823,
        3849, 3872, 3895, 3917, 3937, 3956, 3974, 3991, 4006, 4020,
        4033, 4045, 4056, 4065, 4073, 4080, 4086, 4090, 4093, 4095,
        4096
    };
    #endregion

    private static FInt mul( FInt F1, FInt F2 )
    {
        return F1 * F2;
    }

    #region Cos, Tan, Asin
    public static FInt Cos( FInt i )
    {
        return Sin( i + new FInt( 6435, false ) );
    }

    public static FInt Tan( FInt i )
    {
        return Sin( i ) / Cos( i );
    }

    public static FInt Asin( FInt F )
    {
        bool isNegative = F < 0;
        F = Abs( F );

        if ( F > FInt.OneF )
            throw new ArithmeticException( "Bad Asin Input:" + F.ToDouble() );

        FInt f1 = mul( mul( mul( mul( new FInt( 145103 >> FInt.SHIFT_AMOUNT, false ), F ) -
            new FInt( 599880 >> FInt.SHIFT_AMOUNT, false ), F ) +
            new FInt( 1420468 >> FInt.SHIFT_AMOUNT, false ), F ) -
            new FInt( 3592413 >> FInt.SHIFT_AMOUNT, false ), F ) +
            new FInt( 26353447 >> FInt.SHIFT_AMOUNT, false );
        FInt f2 = PI / new FInt( 2, true ) - ( Sqrt( FInt.OneF - F ) * f1 );

        return isNegative ? f2.Inverse : f2;
    }
    #endregion

    #region ATan, ATan2
    public static FInt Atan( FInt F )
    {
        return Asin( F / Sqrt( FInt.OneF + ( F * F ) ) );
    }

    public static FInt Atan2( FInt F1, FInt F2 )
    {
        if ( F2.RawValue == 0 && F1.RawValue == 0 )
            return (FInt)0;

        FInt result = (FInt)0;
        if ( F2 > 0 )
            result = Atan( F1 / F2 );
        else if ( F2 < 0 )
        {
            if ( F1 >= 0 )
                result = ( PI - Atan( Abs( F1 / F2 ) ) );
            else
                result = ( PI - Atan( Abs( F1 / F2 ) ) ).Inverse;
        }
        else
            result = ( F1 >= 0 ? PI : PI.Inverse ) / new FInt( 2, true );

        return result;
    }
    #endregion

    #region Abs
    public static FInt Abs( FInt F )
    {
        if ( F < 0 )
            return F.Inverse;
        else
            return F;
    }
    #endregion

}

public struct FPoint
{
    public FInt X;
    public FInt Y;

    public FPoint( FInt X, FInt Y )
    {
        this.X = X;
        this.Y = Y;
    }

    public static FPoint FromPoint( Point p )
    {
        FPoint f = new FPoint();
        f.X = (FInt)p.X;
        f.Y = (FInt)p.Y;
        return f;
    }

    public static Point ToPoint( FPoint f )
    {
        return new Point( f.X.IntValue, f.Y.IntValue );
    }
}

The code is created from information based here

More fixed point functions can be found written in Java here