# Fraction Math in Beef

Published on 05 February 2024 (Updated: 05 February 2024)

Welcome to the Fraction Math in Beef page! Here, you'll find the source code for this program as well as a description of how the program works.

## Current Solution

``````using System;
using System.Collections;

namespace FractionMath;

struct Fraction : IParseable<Fraction>
{
int32 mNum;
int32 mDen;

public this(int32 num, int32 den)
{
Runtime.Assert(den != 0);
mNum = num;
mDen = den;
reduce();
}

public void reduce() mut
{
if (mDen < 0)
{
mNum = -mNum;
mDen = -mDen;
}

int32 g = gcd(mNum, mDen);
mNum /= g;
mDen /= g;
}

public static int32 gcd(int32 num, int32 den)
{
Runtime.Assert(den != 0);
int32 a = num >= 0 ? num : -num;
int32 b = den >= 0 ? den : -den;
while (b != 0)
{
(a, b) = (b, a % b);
}

return a;
}

public static Result<Fraction> Parse(StringView str)
{
int32[] arr = scope int32[2] (0, 1);
int index = 0;
for (StringView part in str.Split('/', 2))
{
StringView trimmedStr = scope String(part);
trimmedStr.Trim();

// T.Parse ignores single quotes since they are treat as digit separators -- e.g. 1'000
if (trimmedStr.Contains('\''))
{
return .Err;
}

switch (Int32.Parse(trimmedStr))
{
case .Ok(out arr[index]):
case .Err:
return .Err;
}

index++;
}

return .Ok(Fraction(arr[0], arr[1]));
}

public static Fraction operator +(Fraction lhs, Fraction rhs)
{
// n1/d1 + n2/d2 = (n1*d2 + n2*d1) / (d1*d2)
return .(lhs.mNum * rhs.mDen + rhs.mNum * lhs.mDen, lhs.mDen * rhs.mDen);
}

public static Fraction operator -(Fraction lhs, Fraction rhs)
{
// n1/d1 - n2/d2 = (n1*d2 - n2*d1) / (d1*d2)
return .(lhs.mNum * rhs.mDen - rhs.mNum * lhs.mDen, lhs.mDen * rhs.mDen);
}

public static Fraction operator *(Fraction lhs, Fraction rhs)
{
// n1/d1 * n2/d2 = (n1*n2) / (d1*d2)
return .(lhs.mNum * rhs.mNum, lhs.mDen * rhs.mDen);
}

public static Fraction operator /(Fraction lhs, Fraction rhs)
{
// (n1/d1) / (n2/d2) = (n1*d2) / (d1*n2)
return .(lhs.mNum * rhs.mDen, lhs.mDen * rhs.mNum);
}

public static int operator <=>(Fraction lhs, Fraction rhs)
{
// (n1/d1) <=> (n2/d2) = n1*d2 <=> d1*n2
return (lhs.mNum * rhs.mDen) <=> (lhs.mDen * rhs.mNum);
}

public override void ToString(String str)
{
str.Clear();
str.AppendF(\$"{mNum}/{mDen}");
}
}

class Program
{
public static void Usage()
{
Console.WriteLine("Usage: ./fraction-math operand1 operator operand2");
Environment.Exit(0);
}

public enum FractionResult
{
case Frac(Fraction f);
case Bool(bool b);

public override void ToString(String str)
{
switch (this)
{
case .Frac(let f):
f.ToString(str);

case .Bool(let b):
((b) ? 1 : 0).ToString(str);
}
}
}

public static Result<FractionResult> FractionMath(Fraction f1, Fraction f2, String op)
{
switch (op)
{
case "+":  return .Ok(.Frac(f1 + f2));
case "-":  return .Ok(.Frac(f1 - f2));
case "*":  return .Ok(.Frac(f1 * f2));
case "/":  return .Ok(.Frac(f1 / f2));
case ">":  return .Ok(.Bool(f1 > f2));
case ">=": return .Ok(.Bool(f1 >= f2));
case "<":  return .Ok(.Bool(f1 < f2));
case "<=": return .Ok(.Bool(f1 <= f2));
case "==": return .Ok(.Bool(f1 == f2));
case "!=": return .Ok(.Bool(f1 != f2));
default:   return .Err;
}
}

public static int Main(String[] args)
{
if (args.Count < 3)
{
Usage();
}

Fraction f1 = ?;
switch (Fraction.Parse(args[0]))
{
case .Ok(out f1):
case .Err:
Usage();
}

String op = scope String(args[1]);

Fraction f2 = ?;
switch (Fraction.Parse(args[2]))
{
case .Ok(out f2):
case .Err:
Usage();
}

switch (FractionMath(f1, f2, op))
{
case .Ok(let res):
Console.WriteLine(res);

case .Err:
Usage();
}

return 0;
}
}

``````

Fraction Math in Beef was written by:

• rzuckerm

If you see anything you'd like to change or update, please consider contributing.

## How to Implement the Solution

No 'How to Implement the Solution' section available. Please consider contributing.

## How to Run the Solution

No 'How to Run the Solution' section available. Please consider contributing.