Implement a simple class in your favorite language.

Question

I'm doing this to learn the syntax of different programming languages.

So, how would you defined the following class along with with its operations in your favorite programming language?

_{Image generated by http://yuml.me/}

And a main method or equivalent to invoke it:

For instance, for Java it would be:

...
public static void main( String [] args ) {
    Fraction f = new Fraction();

    f.numerator( 2 );
    f.denominator( 5 );
    f.print();
    // using the "getters"
    int n = f.numerator();
    int d = f.denominator();
}
....

EDIT

This is not intended for production code!

The purpose is merely to learn from others how to write the most basic data structure.

I know and agree that immutability is much better and the class needs a "test-specification" to work properly and Fraction is already a core class in many languages. Forget about the semantics

Answer 1

Ruby:

class Fraction
  attr_accessor :numerator, :denominator

  def print
    "#{numerator}/#{denominator}"
  end
end

f = Fraction.new
f.numerator = 2
f.denominator = 3
f.print # => "2/3"
n = f.numerator
d = f.denominator

Answer 2

I disagree with a mutable class for this. The following example still allows the numerator/denominator "setters" but returns a new Fraction object. The names are withNumerator and withDenominator to indicate this fact but they could easily be numerator or denominator (or even numerator=/denominator=, but that's just ... wrong):

case class Fraction(_numerator: Int, _denominator: Int) {
  def numerator = _numerator                            // getter
  def withNumerator(n: Int) = Fraction(n, _denominator) // returns NEW object
  def denominator = _denominator
  def withDenominator(n:Int) = Fraction(_numerator, n)
  override def toString = "" + numerator + "/" + denominator
  def print = println(this)
}

val f = Fraction(0,0).withNumerator(22).withDenominator(7)
f.print                // 22/7
val n = f.numerator
val d = f.denominator

Here is a version that just exposes the members directly so they are mutable:

case class Fraction(var numerator: Int, var denominator: Int) {
  override def toString = "" + numerator + "/" + denominator
  def print = println(this)
}

val f = Fraction(0,0)
f.numerator = 22  // direct member access
f.denominator = 7
f.print           // 22/7
val n = f.numerator
val d = f.denominator

Here is a version with plain "getters/setters" (just wrap the members and mutate the object):

case class Fraction(var _numerator: Int, var _denominator: Int) {
  def numerator = _numerator               // getter
  def numerator_=(n: Int) = _numerator = n // setter -- mutating
  def denominator = _denominator
  def denominator_=(n:Int) = _denominator = n
  override def toString = "" + numerator + "/" + denominator
  def print = println(this)
}

val f = Fraction(0,0)
f.numerator = 22   // setter -- mutating
f.denominator = 7
f.print            // 22/7
val n = f.numerator
val d = f.denominator

Answer 3

C#

public class Fraction
{
    public Fraction() {}

    public int numerator { get;set; }
    public int denominator { get;set; }
    public override ToString( ) 
    {
        return this.numerator.ToString() + "/" + 
               this.denominator.ToString(); 
    }
    public void Print() 
    {
         System.Console.WriteLine( this );
    }
    public static void Main( string [] args ) 
    {
        Fraction f = new Fraction();
        f.numerator = 2;
        f.denominator = 5;
        f.Print();
     }
}

Answer 4

C++

#include <iostream>

class Fraction
{
    int m_numerator;
    int m_denominator;
public:
    Fraction(int numerator, int denominator) 
        : m_numerator(numerator)
        , m_denominator(denominator) {
    }
    void SetNumerator(int val) {
        m_numerator = val;
    }
    void SetDenominator(int val) {
        m_denominator = val;
    }
    int GetNumerator() const {
        return m_numerator;
    }
    int GetDenominator() const {
        return m_denominator;
    }
    void print() const {
        std::cout << m_numerator << "/" << m_denominator;
    }
};

// Main method - Entry point
int main()
{
    // declare an instance of the class
    Fraction f(5,5);
    f.print();
}

Answer 5

C ;-)

#include <stdio.h>

struct Fraction {
    int numerator;
    int denominator;
};

void Fraction_print(const struct Fraction *f) {
    printf("%d/%d\n", f->numerator, f->denominator);
}

int main() {
    struct Fraction f = {1, 2};
    Fraction_print(&f);
    f.numerator = 2;
    f.denominator = 3;
    Fraction_print(&f);
    return 0;
}

Obviously if you want to do stuff like reduce to simplest form in the setters, you can define those as functions too.

Answer 6

Another attempt on C++

class Fraction {
   int m_numerator, m_denominator;

public:
   int numerator() const {
      return m_numerator;
   }
   int denominator() const {
      return m_numerator;
   }
   void numerator(const int new_numerator) {
      m_numerator = new_numerator;
   }
   void denominator(const int new_denominator) {
      m_denominator = new_denominator;
   }
   void print() const {
      // Printing implementation
   }
};

void main() {
   Fraction f;
   f.numerator(2);
   f.denominator(5);
   f.print();
}

Answer 7

Python 2:

class Fraction(object):
    def __init__(self, numerator=0, denominator=1):
        self.numerator = numerator 
        self.denominator = denominator
    def __str__(self):
        return "%s / %s" % (self.numerator, self.denominator)

def main():
    f = Fraction(1, 2)
    print f
    f.numerator = 2
    f.denominator = 3
    print f

if __name__ == "__main__":
    main()

Answer 8

ABAP:

CLASS Fraction DEFINITION.
  PUBLIC SECTION.
    METHODS numerator IMPORTING i_numerator TYPE I.
    METHODS denominator IMPORTING i_denominator TYPE I.
    METHODS ToString RETURNING value(r_fraction) TYPE string.
    METHODS Print.
  PROTECTED SECTION.
    DATA: v_numerator TYPE   I,
          v_denominator TYPE I.
ENDCLASS. ""End Definition

CLASS Fraction IMPLEMENTATION.
  METHOD numerator.
    v_numerator = i_numerator.
  ENDMETHOD.

  METHOD denominator.
    v_denominator = i_denominator.
  ENDMETHOD.

  METHOD ToString.
    CONCATENATE v_numerator
                "/"
                v_denominator
           INTO r_fraction.
  ENDMETHOD.

  METHOD Print.
    DATA v_fraction.
    CONCATENATE v_numerator
                "/"
                v_denominator
           INTO v_fraction.
    WRITE: v_fraction, /.
  ENDMETHOD.

ENDCLASS. "End Implementation

Answer 9

F#: lots of different ways to make classes:

Vanilla class:

type Fraction(numerator : int, denominator : int) =
    member this.Numerator = numerator
    member this.Denominator = denominator
    override this.ToString() = sprintf "%i / %i" numerator denominator

let f = new Fraction(2, 3)

Record:

type fraction = { numerator : int; denominator : int }
    with
        override this.ToString() = sprintf "%i / %i" this.numerator this.denominator

let f = { numerator = 2; denominator = 3 }

Union:

type fraction = Fraction of int * int
    with
        member this.Numerator = match this with Fraction(x, y) -> x
        member this.Denominator = match this with Fraction(x, y) -> y
        override this.ToString() = match this with Fraction(x, y) -> sprintf "%i / %i" x y

let f = Fraction(2, 3)

Usage:

printfn "%O" f

Answer 10

Python:

from fractions import Fraction

Answer 11

Go (my Go style is not very developed. Also, I don't have the compiler on this machine to test. Here goes anyway):

package main

import  "fmt"

type Fraction struct {
    numerator int
    denominator int
}

// Go doesn't have function/method overloading
func ( frac *Fraction ) SetNumerator( v int )  {
    frac.numerator = v
}
func( frac *Fraction ) SetDenominator( v int )  {
    frac.denominator = v
}
func(frac *Fraction ) Numerator() int {
    return frac.numerator
}
func( frac *Fraction ) Denominator() int {
    return frac.denominator
}
func( frac *Fraction ) Print()  {
    fmt.Printf("%d/%d\n",frac.Numerator(), frac.Denominator())
}

func main() {
    f:=&Fraction{}
    f.SetNumerator(1)
    f.SetDenominator(2)

    f.Print()
}

Answer 12

I guess I'd actually want to write something like this in Java:

public final class Fraction implements Comparable<Fraction> {
    private final int num;
    private final int den;

    private Fraction(int num, int den) {
        if (den == 0) {
            throw new ArithmeticException();
        }
        int gcd = gcd(num, den); // To do...
        this.num = num/gcd;
        this.den = den/gcd;
    }
    public static Fraction of(int num, int den) {
        return new Fraction(num, den);
    }

    public int numerator() {
        return num;
    }
    public int denominator() {
        return den;
    }

    @Override public boolean equals(Object obj) {
        if (!(obj instanceof Fraction)) {
            return false;
        }
        Fraction other = (Fraction)obj;
        return this.num == other.num && this.den == other.den;
    }
    @Override public int hashCode() 
        int h = den;
        h = h*41 + num;
        return h;
    }
    @Override public String toString() {
        return num+"@"+den;
    }

    public int compareTo(Fraction other) {
        return Longs.compare( // To do...
            this.num*(long)other.den,
            other.num*(long)this.den
        );
    }
}

...

public static void main(String [] args) {
    Fraction fraction = Fraction.of(2, 5);
    System.out.println(fraction)

    // using the "getters"
    int num = fraction.numerator();
    int den = fraction.denominator();
}

There is a suggest that Java should have direct support to make immutable values simpler.

What actually get written:

public class Fraction implements Serializable {
    public int numerator, denominator;
}

(See java.awt.Point.)

Answer 13

C# - Because you wanted to compare languages and I'm bored, here is a more java like way of defining the class that also works. Please note I wouldn't actually do it this way, @Muad'dib has the standard approach in C#. I'm just putting this in for completeness sake and so you see how close C# can be to Java with simple code like this. Note that C# will not let you name a field and method the same (no overloading between the fields and methods).

public class Fraction
{
    private int numerator;
    private int denominator;

    public int Numerator()
    {
        return numerator;
    }

    public void Numerator(int val)
    {
        numerator = val;
    }

    public int Denominator()
    {
        return denominator;
    }

    public void Denominator(int val)
    {
        denominator = val;
    }

    public void Print()
    {
        Console.WriteLine(numerator);
        Console.WriteLine(denominator);
    }
}
// in whatever your startup class is.
static void Main(string[] args)
{
    Fraction f = new Fraction();
    f.Numerator(2);
    f.Denominator(5);
    f.Print();
    // using the "getters"
    int n = f.Numerator();
    int d = f.Denominator();
}

Answer 14

7Basic

CLASS Fraction
    FUNCTION SetNumerator (val AS INTEGER)
        numerator = val
    END FUNCTION
    FUNCTION SetDenominator (val AS INTEGER)
        denominator = val
    END FUNCTION

    FUNCTION GetNumerator ()
        RETURN numerator
    END FUNCTION
    FUNCTION GetDenominator ()
        RETURN denominator
    END FUNCTION

    FUNCTION print ()
        // print the data
    END FUNCTION

    DIM numerator AS INTEGER
    DIM denominator AS INTEGER
END CLASS

And to use the class:

DIM f AS FRACTION

f.SetNumerator( 5 )
f.SetDenominator( 5 )

f.print()

Answer 15

So, how would you defined the following class along with with its operations in your favorite programming language?

I wouldn't. The only useful thing this class can do is print itself. Exposing its numerator and denominator as properties don't provide you with anything more than named integers. I can do that by just typing var numerator = 69, no type def needed.

What you should do is make Fraction immutable, overload math operators, and create math functions for which there aren't operators (Math.Pow, for example).

However, because I'm lazy, I'm only going to provide an implementation for the first thing I said.

using System;

public class Fraction
{
    public Fraction(int numerator, int denominator)
    {
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public void Print()
    {
        Console.WriteLine(numerator + "/" + denominator);
    }

    readonly int numerator;
    readonly int denominator;
}

static class EntryPoint
{
    static void Main()
    {
        var twoThirds = new Fraction(2, 3);
        twoThirds.Print();
    }
}

Answer 16

Python 3.x:

class Fraction:
    def __init__(self, num, denom):
        self.__numerator = num
        self.__denominator = denom

    def numerator(self, num=None):
        if num is not None:
            self.__numerator = num
            return None
        return self.__numerator

    def denominator(self, denom=None):
        if denom is not None:
            self.__denominator = denom
            return None
        return self.__denominator

    def __str__(self):
        return "{0}/{1}".format(self.__numerator, self.__denominator)

    # Printable representation of the Fraction instance (included for
    # debugging, hence the details provided and the difference between
    # the __repr__ and the __str__ definitions).
    def __repr__(self):
        return "{0}({1}, {2})".format(self.__class__,
                                      self.__numerator,
                                      self.__denominator)

Answer 17

Javascript:

function Fraction(numerator, denominator)
{
  var _numerator = numerator;
  var _denominator = denominator;

  var outputFunction = document.writeln;


    this.numerator = function(value)
    {
        if(value) _numerator = value;
        else return _numerator;
    }

    this.denominator = function(value)
    {
        if(value) _denominator = value;
        else return _denominator;
    }

    this.print = function()
    {
        outputFunction(this.numerator() + "/" + this.denominator());
    }
}

var f = new Fraction(1,2);
f.print();
f.numerator(5);
f.denominator(11);
f.print();

var n = f.numerator();
var d = f.denominator();

document.writeln(n + "/" + d);

Answer 18

JavaScript:

<script type="text/javascript">

function print(str) {
    document.write(str + '<br/>\n');
}

var Fraction = function(n, d){
    var that = this; 
    var frac = [1, 0];

    if (n !== undefined)
        frac[0] = parseInt(n);
    if (d !== undefined)
        frac[1] = parseInt(d);

    function accessor(index) {
        return function(value){
            if (value === undefined)
                return frac[index];
            frac[index] = parseInt(value);
            return that; // Allow chaining
        };
    }


    that.numerator = accessor(0);
    that.denominator = accessor(1);
    that.toString = function(){
        return frac[0] + '/' + frac[1];
    };
    that.print = function(){
        print(that);
    };
    that.pie = function(){
        /* Does not support improper fractions. */
        var a = frac[0];
        var b = frac[1] - frac[0];
        print('<img src="http://chart.apis.google.com/chart?cht=p3&amp;chd=t:'
            +a+','+b+'&chs=300x150"/>');
    };

    return that;
}

var f = new Fraction(1, 3);
f.print();
f.numerator(2).denominator(5);
f.print();

print('numerator: ' + f.numerator());
print('denominator: ' + f.denominator());

(new Fraction(3,4)).pie();

</script>

Answer 19

Perl 5

Man, I'm super rusty on object-oriented Perl and I wouldn't say it's my favourite language by a long shot, but since no-one else has done it yet...

#!/usr/bin/perl

use strict;
use warnings;

package Fraction;
sub new {
    my $class = shift;

    my $this = {};
    $this->{numerator} = shift;
    $this->{denominator} = shift;
    bless($this, $class);
    return $this;
}

sub numerator {
    return shift->{numerator};
}
sub denominator {
    return shift->{denominator};
}
sub set_numerator { 
    my ($this, $num) = @_;
    $this->{numerator} = $num;
}
sub set_denominator {
    my ($this, $den) = @_;
    $this->{denominator} = $den;
}
sub str {
    my $this = shift;
    return sprintf("%s / %s", $this->numerator(), $this->denominator());
}


package Main;

my $f = Fraction->new(1, 2);
print $f->str(), "\n";
$f->set_numerator(2);
$f->set_denominator(5);
print $f->str(), "\n";

Answer 20

Haskell

data Fraction = F { num :: Integer, den :: Integer }
                deriving (Show)

Answer 21

Objective-C, using synthesized properties:

@interface Fraction : NSObject {
    int numerator;
    int denominator;
}

@property (assign) int numerator;
@property (assign) int denominator;
- (id)initWithNumerator:(int)theNumerator denominator:(int)theDenominator;
- (void) print;

@end

@implementation Fraction

@synthesize numerator, denominator; //implements getters and setters

- (id)initWithNumerator:(int)theNumerator denominator:(int)theDenominator {
    self = [super init];
    if (!self)
        return nil;

    numerator = theNumerator;
    denominator = theDenominator;

    return self;
}

- (id)init {
    return [self initWithNumerator:0 denominator:1];
}

- (NSString *) description { //equivalent of toString() in Java
    return [NSString stringWithFormat:@"%d/%d", self.numerator, self.denominator];
}    

- (void) print {
    NSLog(@"%@", self);
}

@end

int main(int argc, char **argv) {
    Fraction f = [[Fraction alloc] init];
    f.numerator = 2;
    f.denominator = 5;
    [f print];
    int n = f.numerator;
    int d = f.denominator;
    [f release];

    return 0;
}

Answer 22

Common Lisp (which already has a rational type)

(defclass fraction ()
  (
   (numer :accessor numer :initarg :numer :initform 0 :type integer)
   (denom :accessor denom :initarg :denom :initform 1 :type integer)
   ) )

(defmethod print-object ((r fraction) stream)
  (format stream "~A/~A" (numer r) (denom r) ))

(defvar f (make-instance 'fraction :numer 2 :denom 5))
(print-object f t)
(defvar n (numer f))
(defvar d (numer d))

;; Not necessary, but somewhat useful
(defun make-fraction (&optional (n 0) (d 1) &rest initargs) 
  (declare (type integer n d))
  (apply #'make-instance 'fraction :numer n :denom d initargs))
(defvar half (make-fraction 1 2))

Answer 23

You know what you don't see anymore?

SIMULA

Begin
    Class Fraction (Numerator, Denominator) Integer Numerator, Denominator;
    Begin
        Procedure Print;
        Begin
            OutInt(Numerator,7);OutChar('/');OutInt(Denominator,7);OutImage
        End;
    End;

    Ref(Fraction) F;
    F :- New Fraction(2,3);
    F.Print
End;

Take with a pinch of salt. This is based on my 25 year old recollection.

Answer 24

PowerShell:

function Fraction {
  new-object PSObject | select numerator, denominator | 
    add-member -passthru -membertype scriptmethod -name print -value { 
      write-host "$($this.numerator)/$($this.denominator)"
  }
}

$obj = Fraction
$obj.numerator = 3
$obj.denominator = 5
$obj.print()
$i = $obj.numerator
$d = $obj.denominator

Answer 25

Another Javascript implementation, using prototype, getters and setters:

function Fraction(n, d) {
    this.numerator = n;
    this.denominator = d;
}

Fraction.prototype = {
    get numerator() { return this.numer; },
    set numerator(n) { this.numer = n; },
    get denominator() { return this.denom; },
    set denominator(d) { this.denom = d; },
    toString: function () {
        return this.numerator + '/' + this.denominator;
    }
};

var f = new Fraction();
f.numerator = 2;
f.denominator = 5;
f + ''
var n = f.numerator;
var d = f.denominator;

Answer 26

Punched Cards

*     *    *        *    *
*          *    *        *
      *    *    *
      *    *    *    *
*     *    *        *    *
*          *    *        *

Usage

   *  *    *    *    *    *
*          *    *        *
   *  *            *
                *    *
*     *    *        *     
*               *        *

Answer 27

Groovy:

class Fraction {
    def numerator, denomenator

    def print() {
        print "$numerator/$denomenator"
    }
}

def frac = new Fraction()
frac.numerator = 1
frac.denomenator = 2
frac.print()
def n = frac.numerator
def d = frac.denomenator

Answer 28

C#

    public class Fraction
    {
        public int Numerator { get; set; }

        private int _denominator;
        public int Denominator
        {
            get
            {
                return _denominator;
            }
            set
            {
                if (value != 0)
                    _denominator = value;
                else
                    throw new ArgumentException("Denominator must be non-zero.");
            }
        }


        public Fraction(int numerator, int denominator)
        {
            Numerator = numerator;
            Denominator = denominator;
        }

        public override string ToString()
        {
            return string.Format("{0}/{1}", Numerator, Denominator);
        }

        public static implicit operator double(Fraction f)
        {
            return f.Numerator / f.Denominator;
        }

Answer 29

Lua: depends on the class library you use. If you use something like LOOP, then it looks like this:

require 'loop.simple'

local fraction = loop.simple.class {
    data = { -- have to do this because i canot define multiple things to be the same name in a given scope
        numerator = 0,
        denominator = 0,
    },
    fracPrint = function(self)
        print(self.data.numerator .. '/' .. self.data.denominator)
    end,
    numerator = function(self, value) -- note that this is not usually how things are defined in lua, but to match your "spec" i wrote these two functions like this
        if value then self.data.numerator = value else return self.data.numerator end
    end,
    denominator = function(self, value)
        if value then self.data.denominator = value else return self.data.denominator end
    end,
}

local myFraction = fraction()
myFraction:fracPrint()
myFraction:numerator(1)
myFraction:denominator(2)
myFraction:fracPrint()

local myNum = myFraction:numerator()
local myDen = myFraction:denominator()
print(myNum .. '/' .. myDen)

Answer 30

Not my favorite language but others were taken.

ActionScript:

package {
  public class Fraction {
    private var n:int;
    private var d:int;
    public Fraction( numerator:int , denominator:int ) { n = numerator; d = denominator; }
    public get numerator():int { return n; }
    public get denominator():int { return d; }
    public set numerator( numerator:int ) { n = numerator; }
    public set denominator( denominator:int ) { d = denominator; }
    public print() { trace( "" + n + "/" + d ); }
  }
}

var f:Fraction = new Fraction( 1 , 2 );
f.print();

Answer 31

Wow, no love whatsoever for VB.NET, huh?

UPDATE: In deference to Konrad Rudolph, whose rep could beat the crap out of mine and steal its lunch money, here is a proposed VB.NET solution which takes liberties with the spec on the premise that a proper design would deviate from the requirements provided:

Public Class Fraction

    Private ReadOnly _numerator As Integer
    Public ReadOnly Property Numerator() As Integer
        Get
            Return _numerator
        End Get
    End Property

    Private ReadOnly _denominator As Integer
    Public ReadOnly Property Denominator() As Integer
        Get
            Return _denominator
        End Get
    End Property

    Sub New(ByVal numerator As Integer, ByVal denominator As Integer)
        _numerator = numerator
        _denominator = denominator
    End Sub

    Public Overrides Function ToString() As String
        Return String.Format("{0} / {1}", _numerator, _denominator)
    End Function

End Class

Usage demo:

Sub Main()
    ' Fraction class is immutable; '
    ' numerator and denominator must be set in the constructor. '
    Dim f As New Fraction(2, 3)

    ' This is how a Fraction would be printed to the console. '
    Console.WriteLine(f.ToString())

    ' Numerator and Denominator properties are publicly '
    ' accessible, but cannot be modified. '
    Dim numerator As Integer = f.Numerator
    Dim denominator As Integer = f.Denominator
End Sub

Answer 32

(defrecord Fraction [numerator denominator])

This is a new Clojure feature, so there aren't any factory methods for creating an instance of the defrecord. If you're feeling verbose, you can do (defn make-fraction [numer denom] (Fraction. numer denom))

The fields can be accessed with keywords:

(:numerator instance-of-fraction)
(:denominator instance-of-fraction)

And toString is already implemented, so the normal print and println functions will work for it.

Setters are irrelevant as well, as they'd just be wrapping assoc:

(assoc instance-of-fraction :numerator 3) ; sets numerator to 3. Actually, returns a new instance of Fraction.

Answer 33

in REBOL

;; create the model object
    fraction: make object! [
      numerator: none
      denominator: none
      print: does [source self self]
      ]


;; create an instance:
    f: make fraction []
    f/numerator: 2
    f/denominator: 5

;; Or, in one line:
    f: make fraction [numerator: 2 denominator: 5]


;; using print, and seeing the console output:
    f/print
    >> self: make object! [
    >> numerator: 2
    >> denominator: 5
    >> print: func [][source self]
    >>    ]

Answer 34

32-bit x86 assembly using MASM (as best as I can remember, and it calls printf() to do the printing):

.model flat

Fraction STRUCT
  numerator DWORD ?
  denominator DWORD ?
Fraction ENDS

.const
fraction_print_format db "%d/%d",0

.code

;void _stdcall Fraction_SetNumerator(Fraction*p,unsigned int v);
public _Fraction_SetNumerator
  pop ebx
  pop eax
  pop (Fraction ptr [eax]).numerator
  jmp ebx

;void _stdcall Fraction_SetDenominator(Fraction*p,unsigned int v);
public _Fraction_SetDenominato
  pop ebx
  pop eax
  pop (Fraction ptr [eax]).denominator
  jmp ebx

;int _stdcall Fraction_GetNumerator(const Fraction*p);
public _Fraction_GetNumerator
  pop ebx
  pop eax
  mov eax,(Fraction ptr [eax]).numerator
  jmp ebx

;int _stdcall Fraction_GetDenominator(const Fraction*p);
public _Fraction_GetDenominator
  pop ebx
  pop eax
  mov eax,(Fraction ptr [eax]).denominator
  jmp ebx

;void _stdcall Fraction_Print(const Fraction*p);
public _Fraction_Print
  mov eax,[esp+4]
  push (Fraction ptr [eax]).denominator
  push (Fraction ptr [eax]).numerator
  push offset fraction_print_format
  call _printf
  add esp,12
  retf 8

Answer 35

In Tcl, the class definition can be:

oo::class create Fraction {
    variable numerator denominator
    constructor {} {
        set numerator [set denominator 0]
    }
    method numerator {{newNum ""}} {
        set numerator {*}[lrange [info level 0] 2 end]
    }
    method denominator {{newNum ""}} {
        set denominator {*}[lrange [info level 0] 2 end]
    }
    method print {} {
        puts "$numerator/$denominator"
    }
}

I wouldn't normally write variable accessors like that, as it is quite a bit slower than using something less convoluted, but it does allow the original problem specification to be tackled.

The code to use it according to the original pattern:

set f [Fraction new]
$f numerator 2
$f denominator 5
$f print
set n [$f numerator]
set d [$f denominator]
puts "n=$n, d=$d"

Answer 36

In Scheme, using closure:

(define (fraction n d)
  (lambda (message . args)
    (case message
      ((numerator!) (set! n (car args)))
      ((denominator!) (set! d (car args)))
      ((numerator) n)
      ((denominator) d)
      ((print) (display n) (display "/") (display d)))))

Sample usage:

> (define f (fraction 10 3))
> (f 'numerator)
10
> (f 'denominator)
3
> (f 'numerator! 11)
> (f 'denominator! 2)
> (f 'print)
11/2

Answer 37

In Ada (this could be improved I'm sure):

Specification:

package Fraction is

   type Fraction is private;
   procedure Print (This : Fraction);
   procedure Set_Numerator (This : in out Fraction;
                            A_Numerator : in Integer);
   procedure Set_Denominator (This : in out Fraction;
                              A_Denominator : in Integer);
   function Get_Numerator   (This : Fraction) return Integer;
   function Get_Denominator (This : Fraction) return Integer;

private
   type Fraction is tagged
      record 
         numerator : Integer;
         denominator : Integer;
      end record ;

end Fraction;

Body:

with Ada.Text_IO; use Ada.Text_IO;

package body Fraction is

   function Get_Numerator (This : Fraction) return Integer is
   begin
      return This.Numerator;
   end Get_Numerator;

   function Get_Denominator (This : Fraction) return Integer is
   begin
      return This.Denominator;
   end Get_Denominator;

   procedure Set_Numerator (This : in out Fraction;
                            A_Numerator : in Integer) is
   begin
      This.Numerator := A_Numerator;
   end Set_Numerator;

   procedure Set_Denominator (This : in out Fraction;
                              A_Denominator : in Integer) is
   begin
      This.Denominator := A_Denominator;
   end Set_Denominator;

   procedure Print (This : Fraction) is
   begin
      Put_Line (Integer'Image(This.Numerator));
      Put_Line (Integer'Image(This.Denominator));
   end Print;

end Fraction;

Usage:

with Fraction; use Fraction;

procedure Main
is
  f : Fraction.Fraction;
  n, d : Integer;
begin
  Set_Numerator (f, 2);
  Set_Denominator (f, 3);
  Print(f);
  n := Get_Numerator(f);
  d := Get_Denominator(f);
end Main;

Answer 38

Perl 5 (w/o Moose, but with a bit of metaprogramming)

package Fraction;
use strict;

sub new {
   my $class = shift;
   bless { numerator => shift, denominator => shift }, $class;  
}

# accessor generator
for my $member (qw/numerator denominator/) {
    *{$member} = sub {
        my $self = shift;
        $self->{$member} = shift if $@;
        return $self->{$member};
    }
}

sub print {
    my $self = shift; 
    print "$self->{numerator}/$self->{denominator}\n";
}

Usage

use Fraction;

$f = Fraction->new();
$f->numerator(2);
$f->denominator(5);
$f->print();

$n = $f->numerator();
$d = $f->denominator();

Answer 39

Fortran 2003 =)

Math.f90

MODULE Math

  IMPLICIT NONE

  PRIVATE

  PUBLIC :: Math_Fraction

  TYPE :: Math_Fraction
    PRIVATE
    INTEGER :: numerator_
    INTEGER :: denominator_
  CONTAINS
    PROCEDURE, PASS :: set_numerator
    PROCEDURE, PASS :: set_denominator
    PROCEDURE, PASS :: numerator
    PROCEDURE, PASS :: denominator
    PROCEDURE, PASS :: print
  END TYPE Math_Fraction

  CONTAINS

    SUBROUTINE set_numerator(this, numerator)
      CLASS(Math_Fraction) :: this
      INTEGER, INTENT(IN) :: numerator

      this%numerator_ = numerator
    END SUBROUTINE set_numerator

    SUBROUTINE set_denominator(this, denominator)
      CLASS(Math_Fraction) :: this
      INTEGER, INTENT(IN) :: denominator

      this%denominator_ = denominator
    END SUBROUTINE set_denominator

    FUNCTION numerator(this) RESULT(result)
      CLASS(Math_Fraction) :: this
      INTEGER :: result

      result = this%numerator_
    END FUNCTION numerator

    FUNCTION denominator(this) RESULT(result)
      CLASS(Math_Fraction) :: this
      INTEGER :: result

      result = this%denominator_
    END FUNCTION denominator


    SUBROUTINE print(this)
      CLASS(Math_Fraction) :: this

      WRITE (*, *) this%numerator_, '/', this%denominator_
    END SUBROUTINE print

END MODULE Math

Main.f90

PROGRAM Main

  USE Math

  IMPLICIT NONE

  TYPE(Math_Fraction) :: f

  CALL f%set_numerator(2)
  CALL f%set_denominator(5)

  WRITE (*, *) f%numerator(), '/', f%denominator()

  CALL f%print

END PROGRAM Main

Compile using gfortran 4.5:

$ gfortran -o app Math.f90 Main.f90
$ ./app
           2 /           5
           2 /           5

Answer 40

Surprising no one posted this yet: Pascal (Object Pascal dialect)

program fractions;

type
    { Type declaration }
    Fraction = object

        private
            numerator : integer;
            denominator: integer;


        public
            procedure setNumerator (value : integer);
            function  getNumerator : integer;
            procedure setDenominator (value : integer);
            function  getDenominator : integer; 

            procedure print;
        end;


{ numerator setter }
procedure Fraction.setNumerator (value : integer);
begin
    self.numerator := value
end;


{ numerator getter }
function Fraction.getNumerator : integer;
begin
    getNumerator := numerator;
end;


{ denominator setter }
procedure Fraction.setDenominator (value : integer);
begin
    self.denominator := value;
end;


{ denominator getter }
function Fraction.getDenominator : integer;
begin
    getDenominator := denominator;
end;


{ print fraction on screen }
procedure Fraction.print;
begin
    write (self.numerator);
    write (' / ');
    write (self.denominator);
    writeln;
end;


{ Main program }
{ BTW, for those who never programmed Pascal before, those are comments;) }   
var
    f : Fraction;
    n,d : integer;

begin
    f.setNumerator (2);
    f.setDenominator (5);
    f.print;

    n := f.getNumerator;
    d := f.getDenominator;
end.

Answer 41

Some more Perl examples, since there's more than one way to do it:

the short way:

package Fraction;
    sub new         {shift; bless [@_]}
    sub numerator   {@_ > 1 ? $_[0][0] = $_[1] : $_[0][0]}
    sub denominator {@_ > 1 ? $_[0][1] = $_[1] : $_[0][1]}
    sub print       {print "$_[0][0]/$_[0][1]\n"}

the classical way:

package Fraction;
    sub new {
        my $pkg = shift;
        bless [@_] => $pkg
    }
    sub numerator {
        my $self = shift;
        @_ ? $$self[0] = shift : $$self[0]
    }
    sub denominator {
        my $self = shift;
        @_ ? $$self[1] = shift : $$self[1]
    }
    sub print {
        my $self = shift;
        print "$$self[0]/$$self[1]\n"
    }

a macro/function way:

package Fraction;
    sub self {$_[0]}
    sub arg1 {$_[1]}
    sub get  {@_ == 1}
    sub num  {0}
    sub den  {1}

    sub new {shift; bless [@_]}
    sub numerator {
        &get and &self->[num]
              or &self->[num] = &arg1
    }
    sub denominator {
        &get and &self->[den]
              or &self->[den] = &arg1
    }
    sub print {print &self->[num] .'/'. &self->[den] ."\n"}

to run:

my $fract = Fraction->new(2, 5);

$fract->print;

$fract->numerator(1);
$fract->denominator(4);

print $fract->denominator, "\n";

$fract->print;

and with an lvalue calling style:

package Fraction;
    sub new {shift; bless [@_]}
    sub numerator   :lvalue {$_[0][0]}
    sub denominator :lvalue {$_[0][1]}
    sub print {print &numerator .'/'. &denominator ."\n"}

package main;

$fract = Fraction->new(2, 5);

$fract->print;

$fract->numerator   = 3;
$fract->denominator = 6;

$fract->print;

Answer 42

Scala

It can be as simple as this:

case class Fraction(var num: Int, var den: Int) {
  def print = println(num + "/" + den)
}

or, if you want setter and getter methods:

case class Fraction {
  private var _num: Int
  private var _den: Int

  def this(num: Int, den: Int) {
    _num = num
    _den = den
  }

  def num = _num
  def den = _den

  def num_=(num: Int) {
    _num = num
  }

  def den_=(den: Int) {
    _den = den
  }

  def print = println(_num + "/" + +den)
}

and some code to test it:

object FractionTester extends Application {
  val f = Fraction(2, 5)

  f.print

  val n = f.num
  val d = f.den
}

(note: I've only just typed this code in here, I haven't checked to see if it works properly or even compiles)

Answer 43

class Fraction:
    def __init__(self, numerator, denominator):
        self.numerator = numerator
        self.denominator = denominator

    def __str__(self):
        return "%(numerator)s/%(denominator)s" % self.__dict__

    def __add__(self, other):
        #TODO: check other's type
        return Fraction(self.numerator + other.numerator,
                        self.denominator + other.denominator)

if __name__ == '__main__':
    print Fraction(1, 2) + Fraction(3, 4)

Answer 44

Perl6

(but i'm not really sure, this was as much a learning experience for me as it is for the OP. And I wasn't able to test it... corrections & suggestions welcome!)

use v6;

class Fraction {
   has $.numerator;
   has $.denominator;

   method Str () {
      "$.numerator/$.denominator"
   }
}

main: {
   my $f = Fraction.new(
      numerator => 1,
      denominator => 2,
   );   
   $f.say;

   $f.numerator = 2;
   $f.denominator = 3;

   $f.say;
}

Answer 45

AppleScript:

on makeFraction(n, d)
    script Fraction
        property numerator : n
        property denominator : d
        on asString()
            return (numerator as string) & "/" & denominator as string
        end asString
        on print {}
            display dialog asString()
        end print

        -- Just because we can
        on pronunciation()
            if denominator is 2 then
                if numerator is 1 then
                    return (numerator as string) & " half"
                else
                    return (numerator as string) & " halves"
                end if
            else if numerator is 1 then
                return asString() & "th"
            else
                return asString() & "ths"
            end if
        end pronunciation
        on say
            continue say pronunciation()
        end say
    end script
    return Fraction
end makeFraction

set f to makeFraction(0, 1)
set numerator of f to 2
set denominator of f to 5
tell f to print {}
tell f to say it -- "it" is meaningless here, but can be included for readability
set n to numerator of f
set d to denominator of f

Answer 46

This is MATLAB (TIOBE #20). Its OO is pretty new, only 2 years old, previously it had crippled pseudo-OO with only value "classes". In my opinion they borrowed heavily from python.

classdef (ConstructOnLoad=true) Fraction < handle
    %# Fraction Class
    properties
        numerator
        denominator
    end

    methods
        function obj = Fraction(num, den)
            %# Fraction(Num,Den) - Constructor for Fraction class
            %# set default values for num and den.
            if nargin<2, den = 1; end
            if nargin<1, num = 0; end

            %# set object properties
            obj.numerator = num;
            obj.denominator = den;
        end

        %# Setter for _denominator_ property
        %# Error checking. One should not be able to set denominator to zero
        function set.denominator(obj,den)
            if den == 0, error('Error: denominator was set to zero'); end
            obj.denominator = den;
        end

        %# overload  MATLAB's disp function for printing
        function disp(obj)
            disp([num2str(obj.numerator),'/',num2str(obj.denominator)]); 
        end
    end
end

>> f = Fraction(2,3)

f = 
2/3

>> f.numerator = 2;
>> f.denominator = 5;
>> disp(f)
f =
2/5
>> n = f.numerator
>> d = d.numerator

Answer 47

C - Better abstraction and encapsulation than the others

I'm not satisfied with the versions in C that I've seen. We should use an abstract typedef and private struct thusly:

fraction.h

#ifndef FRACTION_H
#define FRACTION_H

#ifdef __cplusplus
extern "C" {
#endif

struct Fraction_private;
typedef struct Fraction_private Fraction;

Fraction *FractionCreate(int numerator, int denominator);
void FractionDestroy(Fraction *fraction);
int FractionGetNumerator(Fraction *fraction);
int FractionGetDenominator(Fraction *fraction);
void FractionPrint(Fraction *fraction);

#ifdef __cplusplus
} // extern
#endif

#endif

fraction.c

#include "fraction.h"
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>

struct Fraction_private {
        int numerator;
        int denominator;
};

Fraction *FractionCreate(int numerator, int denominator) {
        Fraction *result = malloc(sizeof(*result));
        result->numerator = numerator;
        result->denominator = denominator;
        return result;
}

void FractionDestroy(Fraction *fraction) {
        free(fraction);
}

int FractionGetNumerator(Fraction *fraction) {
        assert(fraction);
        return fraction->numerator;
}

int FractionGetDenominator(Fraction *fraction) {
        assert(fraction);
        return fraction->denominator;
}

void FractionPrint(Fraction *fraction) {
        assert(fraction);
        printf("%d/%d", fraction->numerator, fraction->denominator);
}

Example use:

#include "fraction.h"
#include <stdio.h>

int main() {
        Fraction *f = FractionCreate(2, 4);
        printf("Numerator is %d, denominator is %d\n",
                FractionGetNumerator(f),
                FractionGetDenominator(f));

        printf("Using the print function: ");
        FractionPrint(f);
        printf("\n");

        FractionDestroy(f);
        return 0;
}

Now this looks much cleaner and abstract doesn't it? In fact, when you get down to it, this C is very much like object-oriented languages, just with a different syntax. Private members are inaccessible, and we can only manipulate the type using the predefined functions. We just happen to pass an explicit 'this' argument to each function.

Of course, in a real application a datatype this simple would probably be implemented as a struct on the stack like other solutions have done. But I though this would be nice for people to see that C can in fact do some nice abstract types.

Answer 48

UML:

Answer 49

Here's another quick PHP implementation. Although the other one was perfectly correct and a great example, it became slightly messy in adhering strictly to the UML so I separated the getters and setters.

<?php

class Fraction {

    private $numerator;
    private $denominator;

    public function setNumerator($num) {
        $this->numerator = $num;
    }

    public function setDenominator($den) {
        $this->denominator = $den;
    }

    public function getNumerator() {
        return $this->numerator;
    }

    public function getDenominator() {
        return $this->denominator;
    }

    public function __toString() {
        return sprintf('%d/%d', $this->numerator, $this->denominator);
    }

}

?>

And here is some example usage:

<?php

    $frac = new Fraction();

    $frac->setNumerator(2);
    $frac->setDenominator(4);

    // Prints 2/4
    echo $frac;

?>

Answer 50

This is how it would look in idiomatic Scala:

case class Fraction(numerator: Int, denominator: Int) {
  override def toString = numerator + "/" + denominator
}

object FractionInAction {
  def main(args: Array[String]): Unit = {
    val f = Fraction(2, 5) 
    val n = f.numerator
    val d = f.denominator
    println(f)  // prints "2/5"

    // Getting modified copy
    val f1 = f copy (numerator = f.numerator + 1)
    println(f1) // prints "3/5"
  }
}

PS: I am aware that my Fraction class is immutable and thus doesn't follow the specification. See @Zoltan's answer for non-idiomatic but in-accordance-with-spec Scala solution.

Answer 51

Fun with Ruby

vim fraction.rb

class Fraction
  attr_accessor :numerator
  attr_reader   :denominator

  def initialize(numerator=0, denominator=1)
    @numerator = numerator
    self.denominator = denominator
  end 

  def denominator=(number)
    fail 'Only Chuck Norris can divide by zero!' if number == 0
    @denominator = number
  end 

  def +(other)
    Fraction.new(@numerator   * other.denominator +
                 @denominator * other.numerator,

                 @denominator * other.denominator)
  end 

  #...

  def to_s
    "#{@numerator}/#{@denominator}"
  end 
end

def start_fun
  Fixnum.send :alias_method, :old_div, :/
  Fixnum.send :define_method, :/ do |other|
    Fraction.new(self, other)
  end 
end

def go_back_to_normal
  Fixnum.send :alias_method, :/, :old_div
end

irb -r fraction.rb

start_fun
puts 10/5

=> 10/5

puts 1/2 + 3/4 + 5/6

=> 100/48

go_back_to_normal
puts 10/5

=> 2

Answer 52

LOL

HAI
CAN HAS STDIO?

LET ME SHOW U MAI FARCTION
I HAS A NUMBAR ITZ "NOM" ALWAIZ
I HAS A NUMBAR ITZ "NOMNOM" ALWAIZ
KTHX

KTHXBYE

HAI

I HAS A MUDKIP ITZ A FARCTION
LOL MUDKIP NOM R 2
LOL MUDKIP NOMNOM R 5

MUDKIP SEZ NOM "/" NOMNOM
KTHX

KTHXBYE