Fractions.Json
7.3.0
dotnet add package Fractions.Json version 7.3.0
NuGet\InstallPackage Fractions.Json Version 7.3.0
<PackageReference Include="Fractions.Json" Version="7.3.0" />
paket add Fractions.Json version 7.3.0
#r "nuget: Fractions.Json, 7.3.0"
// Install Fractions.Json as a Cake Addin
#addin nuget:?package=Fractions.Json&version=7.3.0
// Install Fractions.Json as a Cake Tool
#tool nuget:?package=Fractions.Json&version=7.3.0
Introduction
This package contains a data type to calculate with rational numbers. It supports basic mathematic operators such as:
 addition
 subtraction
 multiplication
 division
 remainder
 ..
The fraction data type implements operator overloads and implicit type conversion for convenience.
Creation
You can implicitly cast int
, uint
, long
, ulong
or BigInteger
to Fraction
:
Fraction a = 3; // int
Fraction b = 4L; // long
Fraction c = new BigInteger(3);
// ..
You can explicitly cast decimal
and double
to Fraction
:
var a = (Fraction)3.3m; // decimal
var b = (Fraction)3.3; // double
You can explicitly cast from Fraction
to any supported data type (int
, uint
, long
, ulong
, BigInteger
, decimal
, double
). However, be aware that an OverflowException
will be thrown, if the target data type's boundary values are exceeded.
Constructors
There a three types of constructors available:
new Fraction (<value>)
forint
,uint
,long
,ulong
,BigInteger
,decimal
anddouble
.new Fraction (<numerator>, <denominator>)
usingBigInteger
for numerator and denominator.new Fraction (<numerator>, <denominator>, <reduce>)
usingBigInteger
for numerator and denominator +bool
to indicate if the resulting fraction shall be normalized (reduced).
Static creation methods
Fraction.FromDecimal(decimal)
Fraction.FromDouble(double)
Fraction.FromDoubleRounded(double)
Fraction.FromString(string)
(using current culture)Fraction.FromString(string, IFormatProvider)
Fraction.FromString(string, NumberStyles, IFormatProvider)
Fraction.TryParse(string, out Fraction)
(using current culture)Fraction.TryParse(string, NumberStyles, IFormatProvider, out Fraction)
Creation from double
The double
data type stores its values as 64bit floating point numbers that comply with IEC 60559:1989 (IEEE 754) standard for binary floatingpoint arithmetic. double
cannot store some binary fractions. For example, 1/10, which is represented precisely by .1 as a decimal fraction, is represented by .0001100110011... as a binary fraction, with the pattern 0011 repeating to infinity. In this case, the floatingpoint value provides an imprecise representation of the number that it represents:
var value = Fraction.FromDouble(0.1);
/* Returns 3602879701896397/36028797018963968
* which is 0.10000000000000000555111512312578 */
Console.WriteLine(value);
You can use the Fraction.FromDoubleRounded(double)
method to avoid big numbers in numerator and denominator. But please keep in mind that the creation speed is significantly slower than using the pure value from Fraction.FromDouble(double)
. Example:
var value = Fraction.FromDoubleRounded(0.1);
// Returns 1/10 which is 0.1
Console.WriteLine(value);
Creation from string
The following string patterns can be parsed:
[+/]n
where n is an integer. Examples: +5, 6, 1234, 0[+/]n.m
where n and m are integers. The decimal point symbol depends on the system's culture settings. Examples: 4.3, 0.45[+/]n/[+/]m
where n and m are integers. Examples: 1/2, 4/5, +4/3, 32/100 Example:
var value = Fraction.FromString("1,5", new CultureInfo("deDE"))
// Returns 3/2 which is 1.5
Console.WriteLine(value);
You should consider the TryParse
methods when reading numbers as text from user input. Furthermore it is best practice to always supply a culture information (e.g. CultureInfo.InvariantCulture
). Otherwise you will sooner or later parse wrong numbers because of different decimal point symbols or included Thousands character.
Conversion
You can convert a Fraction
to any supported data type by calling:
.ToInt32()
.ToUInt32()
.ToInt64()
.ToUInt64()
.ToBigInteger()
.ToDecimal()
.ToDouble()
.ToString()
(using current culture).ToString(string)
(using format string and the system's current culture).ToString(string,IFormatProvider)
If the target's data type boundary values are exceeded the system will throw an OverflowException
.
Example:
var rationalNumber = new Fraction(1, 3);
var value = rationalNumber.ToDecimal();
// result is 0.33333
Console.WriteLine(Math.Round(value, 5));
String format
Character  Description 

G  General format: <numerator>/<denominator> e.g. 1/3 
n  Numerator 
d  Denominator 
z  The fraction as integer 
r  The positive remainder of all digits after the decimal point using the format: <numerator>/<denominator> or string.Empty if the fraction is a valid integer without digits after the decimal point. 
m  The fraction as mixed number e.g. 2 1/3 instead of 7/3 
Note: The special characters #, and 0 like in #.### are not supported. Convert the Fraction
to decimal
if you want to display rounded decimal values.
Example:
var value = new Fraction(3, 2);
// returns 1 1/2
Console.WriteLine(value.ToString("m", new CultureInfo("deDE")));
Mathematic operators
The following mathematic operations are supported:
.Reduce()
returns a normalized fraction (e.g. 2/4 → 1/2).Add(Fraction)
returns the sum of(a + b)
.Subtract(Fraction)
returns the difference of(a  b)
.Multiply(Fraction)
returns the product of(a * b)
.Divide(Fraction)
returns the quotient of(a / b)
.Remainder(Fraction)
returns the remainder (or left over) of(a % b)
.Invert()
returns an inverted fraction (same operation as(a * 1)
).Abs()
returns the absolute valuea
Fraction.Pow(Fraction, int)
returns a base raised to a power(a ^ exponent)
(e.g. 1/10^(1) → 10/1)
As extension method:
FractionExt.Sqrt(this Fraction, int)
returns the square root, specifying the precision after the decimal point.
Example:
var a = new Fraction(1, 3);
var b = new Fraction(2, 3);
var result = a * b;
// returns 2/9 which is 0,2222...
Console.WriteLine(result);
Equality operators
Fraction
implements the following interfaces:
IEquatable<Fraction>
,IComparable
,IComparable<Fraction>
Please note that .Equals(Fraction)
will compare the exact values of numerator and denominator. That said:
var a = new Fraction(1, 2, true);
var b = new Fraction(1, 2, false);
var c = new Fraction(2, 4, false);
// result1 is true
var result1 = a == a;
// result2 is true
var result2 = a == b;
// result3 is false
var result3 = a == c;
You have to use .IsEquivalentTo(Fraction)
if want to test nonnormalized fractions for valueequality.
Under the hood
The data type stores the numerator and denominator as BigInteger
. Per default it will reduce fractions to its normalized form during creation. The result of each mathematical operation will be reduced as well. There is a special constructor to create a nonnormalized fraction. Be aware that Equals
relies on normalized values when comparing two different instances.
Build from source
Just run dotnet build c release
.
Required software frameworks
 .Net 7.0 SDK (7.0.11/ SDK 7.0.401)
Product  Versions Compatible and additional computed target framework versions. 

.NET  net5.0 was computed. net5.0windows was computed. net6.0 was computed. net6.0android was computed. net6.0ios was computed. net6.0maccatalyst was computed. net6.0macos was computed. net6.0tvos was computed. net6.0windows was computed. net7.0 was computed. net7.0android was computed. net7.0ios was computed. net7.0maccatalyst was computed. net7.0macos was computed. net7.0tvos was computed. net7.0windows was computed. net8.0 was computed. net8.0android was computed. net8.0browser was computed. net8.0ios was computed. net8.0maccatalyst was computed. net8.0macos was computed. net8.0tvos was computed. net8.0windows was computed. 
.NET Core  netcoreapp2.0 was computed. netcoreapp2.1 was computed. netcoreapp2.2 was computed. netcoreapp3.0 was computed. netcoreapp3.1 was computed. 
.NET Standard  netstandard2.0 is compatible. netstandard2.1 is compatible. 
.NET Framework  net461 was computed. net462 was computed. net463 was computed. net47 was computed. net471 was computed. net472 was computed. net48 was computed. net481 was computed. 
MonoAndroid  monoandroid was computed. 
MonoMac  monomac was computed. 
MonoTouch  monotouch was computed. 
Tizen  tizen40 was computed. tizen60 was computed. 
Xamarin.iOS  xamarinios was computed. 
Xamarin.Mac  xamarinmac was computed. 
Xamarin.TVOS  xamarintvos was computed. 
Xamarin.WatchOS  xamarinwatchos was computed. 

.NETStandard 2.0
 Fractions (>= 7.3.0)
 Newtonsoft.Json (>= 13.0.3)

.NETStandard 2.1
 Fractions (>= 7.3.0)
 Newtonsoft.Json (>= 13.0.3)
NuGet packages
This package is not used by any NuGet packages.
GitHub repositories
This package is not used by any popular GitHub repositories.
Version  Downloads  Last updated 

7.3.0  150  10/1/2023 
7.2.1  381  12/11/2022 
7.2.0  538  11/9/2022 
7.1.0  1,546  2/20/2022 
7.0.0  364  10/6/2021 
6.0.0  424  2/18/2021 
5.0.1  454  11/13/2020 
5.0.0  438  11/13/2020 
4.0.1  690  6/3/2019 
4.0.0  626  6/3/2019 
3.0.1  1,086  5/1/2017 
3.0.0  975  5/1/2017 
2.0.0  1,120  10/29/2015 
1.0.0  1,853  11/16/2013 