Arithmetic/Rational: Difference between revisions

[[Category:Arithmetic]]

 

;Task:

 

 

*   [[Perfect Numbers]]

<br><br>

 

=={{header|Ada}}==

{{works with|ALGOL 68|Standard - no extensions to language used}}

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

FORMAT frac repr = $g(-0)"//"g(-0)$;

candidate, ENTIER sum, real sum, ENTIER sum = 1))

FI

{{out}}

<pre>

Sum of reciprocal factors of 523776 = 2 exactly, about 2.0000000000000000000000000005

</pre>

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

DIM frac{num, den}

DIM Sum{} = frac{}, Kf{} = frac{}, One{} = frac{}

a.num /= a : a.den /= a

IF a.den < 0 a.num *= -1 : a.den *= -1

Output:

<pre>

=={{header|C}}==

C does not have overloadable operators. The following implementation <u>''does not define all operations''</u> so as to keep the example short. Note that the code passes around struct values instead of pointers to keep it simple, a practice normally avoided for efficiency reasons.

#include <stdlib.h>

#define FMT "%lld"

 

return 0;

See [[Rational Arithmetic/C]]

 

<div style="text-align:right;font-size:7pt">''<nowiki>[</nowiki>This section is included from [[Arithmetic/Rational/C sharp|a subpage]] and should be edited there, not here.<nowiki>]</nowiki>''</div>

{{:Arithmetic/Rational/C sharp}}

{{libheader|Boost}}

Boost provides a rational number template.

#include "math.h"

#include "boost/rational.hpp"

}

return 0;

 

=={{header|Clojure}}==

Ratios are built in to Clojure and support math operations already. They automatically reduce and become Integers if possible.

22/7

user> 34/2

17

user> (+ 37/5 42/9)

 

=={{header|Common Lisp}}==

Common Lisp has rational numbers built-in and integrated with all other number types. Common Lisp's number system is not extensible so reimplementing rational arithmetic would require all-new operator names.

for sum = (+ (/ candidate)

(loop for factor from 2 to (isqrt candidate)

sum (+ (/ factor) (/ (floor candidate factor)))))

when (= sum 1)

 

=={{header|D}}==

 

// std.numeric.gcd doesn't work with BigInt.

}

}

Use the <code>-version=rational_arithmetic_main</code> compiler switch to run the test code.

{{out}}

{{libheader| Boost.Rational}}[[https://github.com/MaiconSoft/DelphiBoostLib]]

{{Trans|C#}}

program Arithmetic_Rational;

 

end;

Readln;

{{out}}

<pre>6 is perfect

=={{header|EchoLisp}}==

EchoLisp supports rational numbers as native type. "Big" rational i.e bigint/bigint are not supported.

;; Finding perfect numbers

(define (sum/inv n) ;; look for div's in [2..sqrt(n)] and add 1/n

(when (zero? (modulo n i ))

(set! acc (+ acc (/ i) (/ i n))))))

{{out}}

;; rational operations

(+ 1/42 1/666) → 59/2331

🍏 🍒 🍓 496 is perfect.

🍏 🍒 🍓 8128 is perfect.

 

=={{header|Elisa}}==

type Rational;

Rational(Numerator = integer, Denominater = integer) -> Rational;

else GCD (A, mod(B,A)) ];

 

Tests

 

PerfectNumbers( Limit = integer) -> multi(integer);

];

 

{{out}}

<pre>

 

=={{header|Elixir}}==

import Kernel, except: [div: 2]

[candidate, sum.numerator, (if sum.numerator == 1, do: "perfect!", else: "")]

end

 

{{out}}

 

=={{header|ERRE}}==

 

!

IF RES% THEN PRINT(N;" is perfect") END IF

END FOR

{{out}}

<pre> 6 is perfect

=={{header|F_Sharp|F#}}==

The F# Powerpack library defines the BigRational data type.

 

let perf n = 1N = List.fold (+) 0N (List.map (fun i -> if n % i = 0 then 1N/frac.FromInt(i) else 0N) [2..n])

 

 

=={{header|Factor}}==

<code>ratio</code> is a built-in numeric type.

math.primes.factors math.ranges prettyprint sequences ;

IN: rosetta-code.arithmetic-rational

 

"Perfect numbers <= 2^19: " print

{{out}}

<pre>

=={{header|Fermat}}==

Fermat supports rational aritmetic natively.

for n=2 to 2^19 by 2 do

s:=3/n;

od;

if s=2 then !!n fi;

{{out}}

<pre>

 

=={{header|Forth}}==

\ Uses the stack convention of the built-in "*/" for int * frac -> int

 

 

: rat-inc tuck + swap ;

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

 

implicit none

end function rational_modulo

 

Example:

 

use module_rational

end do

 

{{out}}

<pre>6

=={{header|Frink}}==

Rational numbers are built into Frink and the numerator and denominator can be arbitrarily-sized. They are automatically simplified and collapsed into integers if necessary. All functions in the language can work with rational numbers. Rational numbers are treated as exact. Rational numbers can exist in complex numbers or intervals.

1/2 + 2/3

// 7/6 (approx. 1.1666666666666667)

8^(1/3)

// 2 (note the exact integer result.)

 

=={{header|GAP}}==

Rational numbers are built-in.

# true

2/3 + 3/4;

 

=={{header|Go}}==

 

Code here implements the perfect number test described in the task using the standard library.

 

import (

}

}

{{out}}

<pre>

=={{header|Groovy}}==

Groovy does not provide any built-in facility for rational arithmetic. However, it does support arithmetic operator overloading. Thus it is not too hard to build a fairly robust, complete, and intuitive rational number class, such as the following:

final BigInteger num, denom

 

"${num}//${denom}"

}

 

The following ''RationalCategory'' class allows for modification of regular ''Number'' behavior when interacting with ''Rational''.

 

class RationalCategory {

: DefaultGroovyMethods.asType(a, type)

}

 

Test Program (mixes the ''RationalCategory'' methods into the ''Number'' class):

 

def x = [5, 20] as Rational

catch (Throwable t) { println t.message }

try { println (α as char) }

{{out}}

<pre style="height:30ex;overflow:scroll;">1//4

</pre>

The following uses the ''Rational'' class, with ''RationalCategory'' mixed into ''Number'', to find all perfect numbers less than 2¹⁹:

 

def factorize = { target ->

def trackProgress = { if ((it % (100*1000)) == 0) { println it } else if ((it % 1000) == 0) { print "." } }

 

{{out}}

<pre>...................................................................................................100000

=={{header|Haskell}}==

Haskell provides a <code>Rational</code> type, which is really an alias for <code>Ratio Integer</code> (<code>Ratio</code> being a polymorphic type implementing rational numbers for any <code>Integral</code> type of numerators and denominators). The fraction is constructed using the <code>%</code> operator.

 

-- Prints the first N perfect numbers.

| factor <- [2 .. floor (sqrt (fromIntegral candidate))]

, candidate `mod` factor == 0 ]

 

For a sample implementation of <code>Ratio</code>, see [http://www.haskell.org/onlinereport/ratio.html the Haskell 98 Report].

Additional procedures are implemented here to complete the task:

* 'makerat' (make), 'absrat' (abs), 'eqrat' (=), 'nerat' (~=), 'ltrat' (<), 'lerat' (<=), 'gerat' (>=), 'gtrat' (>)

limit := 2^19

 

if rsum.numer = rsum.denom = 1 then

return c

{{out}}

<pre>Perfect numbers up to 524288 (using rational arithmetic):

Testing absrat( (-1/1), ) ==> returned (1/1)</pre>

The following task functions are missing from the IPL:

return write("Testing ",p,"( ",rat2str(r1),", ",rat2str(\r2) | &null," ) ==> ","returned " || rat2str(p(r1,r2)) | "failed")

end

end

 

The {{libheader|Icon Programming Library}} provides [http://www.cs.arizona.edu/icon/library/src/procs/rational.icn rational] and [http://www.cs.arizona.edu/icon/library/src/procs/numbers.icn gcd in numbers]. Record definition and usage is shown below:

 

addrat(r1,r2) # Add rational numbers r1 and r2.

subrat(r1,r2) # Subtract rational numbers r1 and r2.

 

 

=={{header|J}}==

Rational numbers in J may be formed from fixed precision integers by first upgrading them to arbitrary precision integers and then dividing them:

_3r4

3 %&x: -4

Note that the syntax is analogous to the syntax for floating point numbers, but uses <code>r</code> to separate the numerator and denominator instead of <code>e</code> to separate the mantissa and exponent.

Thus:

| _3r4 NB. absolute value

3r4

0

3r4 ~: 2r5 NB. not equal

 

You can also coerce numbers directly to rational using x: (or to integer or floating point as appropriate using its inverse)

 

3r4

x:inv 3%4

 

Increment and decrement are also included in the language, but you could just as easily add or subtract 1:

 

7r4

<: 3r4

 

J does not encourage the use of specialized mutators, but those could also be defined:

 

(m)=: (".m)+y

)

mutsub=:adverb define

(m)=: (".m)-y

 

Note that the name whose association is being modified in this fashion needs to be quoted (or you can use an expression to provide the name):

 

'n' mutadd 1

7r4

3r4

'n' mutsub 1

 

(Bare words to the immediate left of the assignment operator are implicitly quoted - but this is just syntactic sugar because that is such an overwhelmingly common case.)

 

That said, note that J's floating point numbers work just fine for the stated problem:

Faster version (but the problem, as stated, is still tremendously inefficient):

Exhaustive testing would take forever:

6 28 496 8128

I.is_perfect_rational@x:@"0 i.2^19x

More limited testing takes reasonable amounts of time:

 

=={{header|Java}}==

Uses BigRational class: [[Arithmetic/Rational/Java]]

public static void main(String[] args) {

int MAX_NUM = 1 << 19;

}

}

{{out}}

<pre>Searching for perfect numbers in the range [1, 524287]

'''Unary'''

* `rabs` for unary `abs`

* `rinv` for unary inverse

* `rminus` for unary minus

 

'''module {"name": "Rational"};'''

def gcd(a; b):

# subfunction expects [a,b] as input

end) | sub("0+$";"")

end

end;

 

# pretty print ala Julia

 

'''Perfect Numbers'''

# divisors as an unsorted stream

def divisors:

# Example:

range(1;pow(2;19)) | select( is_perfect )

{{out}}

<pre>

Julia has native support for rational numbers. Rationals are expressed as <tt>m//n</tt>, where <tt>m</tt> and <tt>n</tt> are integers. In addition to supporting most of the usual mathematical functions in a natural way on rationals, the methods <tt>num</tt> and <tt>den</tt> provide the fully reduced numerator and denominator of a rational value.

{{works with|Julia|1.2}}

divisors(n) = foldl((a, (p, e)) -> vcat((a * [p^i for i in 0:e]')...), factor(n), init=[1])

 

lo, hi = 2, 2^19

println("Perfect numbers between ", lo, " and ", hi, ": ", collect(filter(isperfect, lo:hi)))

 

{{out}}

=={{header|Kotlin}}==

As it's not possible to define arbitrary symbols such as // to be operators in Kotlin, we instead use infix functions idiv (for Ints) and ldiv (for Longs) as a shortcut to generate Frac instances.

 

fun gcd(a: Long, b: Long): Long = if (b == 0L) a else gcd(b, a % b)

}

println()

 

{{out}}

=={{header|Liberty BASIC}}==

Testing all numbers up to 2 ^ 19 takes an excessively long time.

n=2^19

for testNumber=1 to n

end if

end function

 

=={{header|Lingo}}==

A new 'frac' data type can be implemented like this:

property num

property denom

if a > b then return me._gcd(b, a mod b)

return me._gcd(a, b mod a)

 

Lingo does not support overwriting built-in operators, so 'frac'-operators must be implemented as functions:

 

----------------------------------------

diff = fSub(a, b)

return diff.num<=0

Usage:

put f.toString()

-- "2/3"

f = frac(23)

put f.toString()

 

Finding perfect numbers:

----------------------------------------

-- Prints all perfect numbers up to n

if sum.denom = sum.num then put i

end repeat

-- 6

-- 28

-- 496

 

=={{header|Lua}}==

 

do

return table.concat(ret, '\n')

end

 

=={{header|M2000 Interpreter}}==

http://www.rosettacode.org/wiki/M2000_Interpreter_rational_numbers

 

Class Rational {

\\ this is a compact version for this task

}

class:

}

}

}

sum=rational(1, 1)

}

Print timecount

 

=={{header|Maple}}==

Maple has full built-in support for arithmetic with fractions (rational numbers). Fractions are treated like any other number in Maple.

> a := 3 / 5;

a := 3/5

> denom( a );

5

However, while you can enter a fraction such as "4/6", it will automatically be reduced so that the numerator and denominator have no common factor:

> b := 4 / 6;

b := 2/3

All the standard arithmetic operators work with rational numbers. It is not necessary to call any special routines.

> a + b;

19

> a - 1;

-2/5

Notice that fractions are treated as exact quantities; they are not converted to floats. However, you can get a floating point approximation to any desired accuracy by applying the function evalf to a fraction.

> evalf( 22 / 7 ); # default is 10 digits

3.142857143

3.142857142857142857142857142857142857142857142857142857142857142857\

142857142857142857142857142857143

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Mathematica has full support for fractions built-in. If one divides two exact numbers it will be left as a fraction if it can't be simplified. Comparison, addition, division, product et cetera are built-in:

3/8

8/4

 

Numerator[6/9]

gives back:

<pre>1/4

3</pre>

As you can see, Mathematica automatically handles fraction as exact things, it doesn't evaluate the fractions to a float. It only does this when either the numerator or the denominator is not exact. I only showed integers above, but Mathematica can handle symbolic fraction in the same and complete way:

(b^2 - c^2)/(b - c) // Cancel

gives back:

b+c

Moreover it does simplification like Sin[x]/Cos[x] => Tan[x]. Division, addition, subtraction, powering and multiplication of a list (of any dimension) is automatically threaded over the elements:

gives back:

To check for perfect numbers in the range 1 to 2^25 we can use:

CheckPerfect[num_Integer]:=If[Total[1/Divisors[num]]==2,AppendTo[found,num]];

Do[CheckPerfect[i],{i,1,2^25}];

gives back:

Final note; approximations of fractions to any precision can be found using the function N.

 

=={{header|Maxima}}==

a: 3 / 11;

3/11

 

ratnump(a);

 

=={{header|Modula-2}}==

 

=={{header|Nim}}==

 

proc `^`[T](base, exp: T): T =

if sum.den == 1:

echo "Sum of recipr. factors of ",candidate," = ",sum.num," exactly ",

Output:

<pre>Sum of recipr. factors of 6 = 1 exactly perfect!

 

=={{header|Objective-C}}==

 

=={{header|OCaml}}==

OCaml's Num library implements arbitrary-precision rational numbers:

open Num;;

 

Printf.printf "Sum of recipr. factors of %d = %d exactly %s\n%!"

candidate (int_of_num !sum) (if int_of_num !sum = 1 then "perfect!" else "")

[http://forge.ocamlcore.org/projects/pa-do/ Delimited overloading] can be used to make the arithmetic expressions more readable:

for candidate = 2 to 1 lsl 19 do

let sum = ref Num.(1 / of_int candidate) in

Printf.printf "Sum of recipr. factors of %d = %d exactly %s\n%!"

candidate Num.(to_int !sum) (if Num.(!sum = 1) then "perfect!" else "")

 

A type for rational numbers might be implemented like this:

 

First define the interface, hiding implementation details:

module type RATIO =

sig

val ( */ ) : t -> t -> t

val ( // ) : t -> t -> t

 

then implement the module:

module Frac : RATIO =

struct

let ( -/ ) {num=n1; den=d1} {num=n2; den=d2} =

norm { num = n1*~d2 -~ n2*~d1; den = d1*~d2 }

 

Finally the use type defined by the module to perform the perfect number calculation:

let () =

for i = 2 to 1 lsl 19 do

Printf.printf "Sum of reciprocal factors of %d = %s exactly %s\n%!"

i (Frac.to_string !sum) (if Frac.to_string !sum = "1" then "perfect!" else "")

which produces this output:

 

=={{header|Ol}}==

Otus Lisp has rational numbers built-in and integrated with all other number types.

(define x 3/7)

(define y 9/11)

(print candidate (if (eq? sum 1) ", perfect" "")))))

(liota 2 1 (expt 2 15)))

{{Out}}

<pre>

</pre>

=={{header|ooRexx}}==

loop candidate = 6 to 2**19

sum = .fraction~new(1, candidate)

end

 

::method init

expose numerator denominator

 

::requires rxmath library

Output:

<pre>

=={{header|PARI/GP}}==

Pari handles rational arithmetic natively.

s=0;

fordiv(n,d,s+=1/d);

if(s==2,print(n))

 

=={{header|Perl}}==

Perl's <code>Math::BigRat</code> core module implements arbitrary-precision rational numbers. The <code>bigrat</code> pragma can be used to turn on transparent BigRat support:

 

foreach my $candidate (2 .. 2**19) {

print "Sum of recipr. factors of $candidate = $sum exactly ", ($sum == 1 ? "perfect!" : ""), "\n";

}

 

=={{header|Phix}}==

{{Trans|Tcl}}

Phix does not support operator overloading (I am strongly opposed to such nonsense), nor does it have a native fraction library, but it might look a bit like this.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">without</span> <span style="color: #000000;">warning</span> <span style="color: #000080;font-style:italic;">-- (several unused routines in this code)</span>

<span style="color: #000000;">get_perfect_numbers</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

Turned out to be slightly slower than native, but worth it for large number support.<br>

See also [[Bernoulli_numbers#Phix|Bernoulli_numbers]] for another example of mpqs in action.

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">/</span><span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">is_perfect</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">num</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">get_perfect_numbers</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

</pre>

<small>Note that power(2,19) took over 270s under mpfr.js, so reduced to power(2,13) on that platform, making it finish in 0.99s</small>

 

=={{header|PicoLisp}}==

 

(for (N 2 (> (** 2 19) N) (inc N))

"Perfect " N

", sum is " (car Sum)

{{out}}

<pre>Perfect 6, sum is 1: perfect

 

=={{header|PL/I}}==

arat: Proc Options(main);

/*--------------------------------------------------------------------

End lcm;

 

{{out}}

<pre>First solve the task at hand

=={{header|Prolog}}==

Prolog supports rational numbers, where P/Q is written as P rdiv Q.

divisor(N, Div) :-

Max is floor(sqrt(N)),

 

?- main.

{{Out}}

<pre>

{{works with|Python|3.0}}

Python 3's standard library already implements a Fraction class:

 

for candidate in range(2, 2**19):

if sum.denominator == 1:

print("Sum of recipr. factors of %d = %d exactly %s" %

It might be implemented like this:

return a // gcd(a,b) * b

 

return float(self.numerator / self.denominator)

def __int__(self):

 

=={{header|Quackery}}==

<code>factors</code> is defined at [[Factors of an integer#Quackery]].

 

 

[ -2 n->v rot

v0= ] is perfect ( n -> b )

 

 

{{out}}

 

Example:

-> (* 1/7 14)

2

 

=={{header|Raku}}==

{{Works with|rakudo|2016.08}}

Raku supports rational arithmetic natively.

my $sum = 1 / $candidate;

for 2 .. ceiling(sqrt($candidate)) -> $factor {

say "Sum of reciprocal factors of $candidate = $sum exactly", ($sum == 1 ?? ", perfect!" !! ".");

}

Note also that ordinary decimal literals are stored as Rats, so the following loop always stops exactly on 10 despite 0.1 not being exactly representable in floating point:

The arithmetic is all done in rationals, which are converted to floating-point just before display so that people don't have to puzzle out what 53/10 means.

 

=={{header|REXX}}==

L=length(2**19 - 1) /*saves time by checking even numbers. */

do j=2 by 2 to 2**19 - 1; s=0 /*ignore unity (which can't be perfect)*/

gcd: procedure; parse arg x,y; if x=0 then return y; do until _==0; _=x//y; x=y; y=_; end; return x

lcm: procedure; parse arg x,y; if y=0 then return 0; x=x*y/gcd(x, y); return x

Programming note: &nbsp; the &nbsp; '''eDivs, gcd, lcm''' &nbsp; functions are optimized functions for this program only.

 

=={{header|Ruby}}==

Ruby has a Rational class in it's core since 1.9.

for candidate in 2 .. 2**19

sum = Rational(1, candidate)

[candidate, sum.to_i, sum == 1 ? "perfect!" : ""]

end

{{out}}

<pre>

 

=={{header|Rust}}==

use std::ops::{Add, AddAssign, Sub, SubAssign, Mul, MulAssign, Div, DivAssign, Neg};

 

}

}

 

=={{header|Scala}}==

{

require(d!=0)

def apply(n:Long)=new Rational(n)

implicit def longToRational(i:Long)=new Rational(i)

 

{

for (candidate <- 2 until 1<<19)

printf("Perfect number %d sum is %s\n", candidate, sum)

}

 

=={{header|Scheme}}==

Scheme has native rational numbers.

{{works with|Scheme|R5RS}}

(do ((candidate 2 (+ candidate 1))) ((>= candidate (expt 2 19)))

(let ((sum (/ 1 candidate)))

(set! sum (+ sum (/ 1 factor) (/ factor candidate)))))

(if (= 1 (denominator sum))

It might be implemented like this:

 

in the library [http://seed7.sourceforge.net/libraries/bigrat.htm bigrat.s7i].

 

include "rational.s7i";

 

end if;

end for;

 

{{out}}

=={{header|Sidef}}==

Sidef has built-in support for rational numbers.

var frac = 0

 

}"

}

{{out}}

<pre>

=={{header|Slate}}==

Slate uses infinite-precision fractions transparently.

20 reciprocal.

(5 / 6) reciprocal.

 

=={{header|Smalltalk}}==

</pre>

{{works with|GNU Smalltalk}} (and all others)

2 to: (2 raisedTo: 19) do: [ :candidate |

sum := candidate reciprocal.

ifFalse: [ ' ' ] }) displayNl

]

 

=={{header|Swift}}==

 

 

extension BinaryInteger {

print("\(candidate) is perfect")

}

 

{{out}}

{{libheader|Wren-rat}}

The latter module already contains support for rational number arithmetic.

 

System.print("The following numbers (less than 2^19) are perfect:")

for (j in Int.properDivisors(i)[1..-1]) sum = sum + Rat.new(1, j)

if (sum == Rat.one) System.print(" %(i)")

 

{{out}}

=={{header|zkl}}==

Enough of a Rational class for this task (ie implement the testing code "nicely").

fcn init(_a,_b){ var a=_a, b=_b; normalize(); }

fcn toString{

else b==1 and a==r;

}

sum,limit := Rational(1,p), p.toFloat().sqrt();

foreach factor in ([2 .. limit]){

if(sum.b==1) println("Sum of recipr. factors of %6s = %s exactly%s"

.fmt(p, sum, (sum==1) and ", perfect." or "."));

{{out}}

<pre>