Check Machin-like formulas: Difference between revisions

 

<br><br>

 

=={{header|Clojure}}==

Clojure automatically handles ratio of numbers as fractions

{{trans|Go}}

(:gen-class))

 

" Display results "

(println "tan " q " = "(tans q)))

{{Output}}

<pre>

(equals 0.9999991882257445)

</pre>

=={{header|D}}==

This uses the module of the Arithmetic Rational Task.

{{trans|Python}}

arithmetic_rational;

 

writefln("%5s: %s", ans == 1 ? "OK" : "ERROR", eqn);

}

{{out}}

<pre> OK: pi/4 = arctan(1/2) + arctan(1/3)

OK: pi/4 = 88*arctan(1/172) + 51*arctan(1/239) + 32*arctan(1/682) + 44*arctan(1/5357) + 68*arctan(1/12943)

ERROR: pi/4 = 88*arctan(1/172) + 51*arctan(1/239) + 32*arctan(1/682) + 44*arctan(1/5357) + 68*arctan(1/12944)</pre>

=={{header|EchoLisp}}==

(lib 'math)

(lib 'match)

(writeln '❌ f '➽ (reduce f) ))))

{{out}}

 

(define machins

(* 44 (arctan 1/5357)) (* 68 (arctan 1/12944)))) ➽ 0.9999991882257442

 

=={{header|Factor}}==

IN: rosetta-code.machin

 

} [ dup tans "tan %u = %u\n" printf ] each ;

 

{{out}}

<pre>

} = 10092...08223/10092...39711

</pre>

=={{header|GAP}}==

The formula is entered as a list of pairs [k, x], where each pair means k*atan(x), and all the terms in the list are summed. Like most other solutions, the program will only check that the tangent of the resulting sum is 1. For instance, <code>Check([[5, 1/2], [5, 1/3]]);</code> returns also <code>true</code>, though the result is 5pi/4.

 

return (a + b) / (1 - a * b);

end;

[[88, 1/172], [51, 1/239], [32, 1/682], [44, 1/5357], [68, 1/12943]]], Check);

=={{header|Go}}==

{{trans|Python}}

 

import (

r := new(big.Rat)

return r.Quo(new(big.Rat).Add(a, b), r.Sub(one, r.Mul(a, b)))

{{out}}

Last line edited to show only most significant digits of fraction which is near, but not exactly equal to 1.

100928883...

</pre>

=={{header|Haskell}}==

import Data.List (foldl')

 

 

putStr "\nnot Machin: "; print not_machin

 

A crazier way to do the above, exploiting the built-in exponentiation algorithms:

 

-- Private type. Do not use outside of the tans function

 

putStr "\nnot Machin: "; print not_machin

=={{header|J}}==

  1  1     2

  1  1     3

 

   machin&> R

   counterExample  NB. Same as final test case with 12943 incremented to 12944

88 1   172

68 1 12944

   machin counterExample

'''Notes''': The function <tt>machin</tt> compares the results of each formula to π/4 (expressed as <tt>1r4p1</tt> in J's numeric notation). The first example above shows the results of these comparisons for each formula (with 1 for true and 0 for false). In J, arctan is expressed as <tt>_3 o. ''values''</tt> and the function <tt>x:</tt> coerces values to exact representation; thereafter J will maintain exactness throughout its calculations, as long as it can.

=={{header|Java}}==

Read formula from file. Parse and evaluate formula.

Implement Fraction class to support task.

import java.io.BufferedReader;

import java.io.File;

}

 

{{out}}

 

</pre>

=={{header|Julia}}==

using AbstractAlgebra # implements arbitrary precision rationals

 

 

runtestmats()

Testing matrices:

Verified as true: tan Tuple{BigInt,Rational{BigInt}}[(1, 1//2), (1, 1//3)] = 1//1

Verified as false: tan Tuple{BigInt,Rational{BigInt}}[(88, 1//172), (51, 1//239), (32, 1//682), (44, 1//5357), (68, 1//12944)] = 1009288018000944050967896710431587186456256928584351786643498522649995492271475761189348270710224618853590682465929080006511691833816436374107451368838065354726517908250456341991684635768915704374493675498637876700129004484434187627909285979251682006538817341793224963346197503893270875008524149334251672855130857035205217929335932890740051319216343365800342290782260673215928499123722781078448297609548233999010983373327601187505623621602789012550584784738082074783523787011976757247516095289966708782862528690942242793667539020699840402353522108223//1009288837315638583415701528780402795721935641614456853534313491853293025565940011104051964874275710024625850092154664245109626053906509780125743180758231049920425664246286578958307532545458843067352531217230461290763258378749459637420702619029075083089762088232401888676895047947363883809724322868121990870409574061477638203859217672620508200713073485398199091153535700094640095900731630771349477187594074169815106104524371099618096164871416282464532355211521113449237814080332335526420331468258917484010722587072087349909684004660371264507984339711

</pre>

=={{header|Kotlin}}==

As the JVM and Kotlin standard libraries lack a BigRational class, I've written one which just provides sufficient functionality to complete this task:

 

import java.math.BigInteger

println(")")

}

 

{{out}}

false << 1 == tan(88*atan(1/172) + 51*atan(1/239) + 32*atan(1/682) + 44*atan(1/5357) + 68*atan(1/12944))

</pre>

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

Tan[2 ArcTan[1/3] + ArcTan[1/7]] == 1

Tan[4 ArcTan[1/5] - ArcTan[1/239]] == 1

44 ArcTan[1/5357] + 68 ArcTan[1/12943]] == 1

Tan[88 ArcTan[1/172] + 51 ArcTan[1/239] + 32 ArcTan[1/682] +

 

{{Out}}

 

False</pre>

=={{header|Maxima}}==

is(tan(atan(1/2)+atan(1/3))=1);

is(tan(2*atan(1/3)+atan(1/7))=1);

is(tan(44*atan(1/57)+7*atan(1/239)-12*atan(1/682)+24*atan(1/12943))=1);

is(tan(88*atan(1/172)+51*atan(1/239)+32*atan(1/682)+44*atan(1/5357)+68*atan(1/12943))=1);

{{out}}

<pre>(%i2)

(%i18)

(%o18) false</pre>

=={{header|Nim}}==

{{libheader|bignum}}

The most important part of our program is the formula parser which proceeds to a full syntactical validation. The parser builds an expression which is a sequence of terms, a term being itself composed of a factor and a fraction (the argument to arctan).

 

 

type

else:

echo "False: ", formula

 

{{out}}

False: pi/4 = 88*arctan(1/172) + 51*arctan(1/239) + 32*arctan(1/682) + 44*arctan(1/5357) + 68*arctan(1/12944)

Tangent of the right expression is about 0.9999991882257444</pre>

=={{header|OCaml}}==

 

let tadd p q = (p +/ q) // ((Int 1) -/ (p */ q)) in

(4,[(88,1,172);(51,1,239);(32,1,682);(44,1,5357);(68,1,12943)]);

(4,[(88,1,172);(51,1,239);(32,1,682);(44,1,5357);(68,1,12944)])

 

Compile with

tan(RHS) is not one

</pre>

=={{header|ooRexx}}==

* 09.04.2014 Walter Pachl the REXX solution adapted for ooRexx

* which provides a function package rxMath

end /*j*/ /* [?] show OK | bad, formula. */

::requires rxmath library

{{out}}

<pre> OK: pi/4=rxCalcarctan(1/2,16,R)+rxCalcarctan(1/3,16,R)

OK: pi/4=88*rxCalcarctan(1/172,16,R)+51*rxCalcarctan(1/239,16,R)+32*rxCalcarctan(1/682,16,R)+44*rxCalcarctan(1/5357,16,R)+68*rxCalcarctan(1/12943,16,R)

bad: pi/4=88*rxCalcarctan(1/172,16,R)+51*rxCalcarctan(1/239,16,R)+32*rxCalcarctan(1/682,16,R)+44*rxCalcarctan(1/5357,16,R)+68*rxCalcarctan(1/12944,16,R)</pre>

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

if (coef <= 1, return(if(coef<1,-tanEval(-coef, f),f)));

my(a=tanEval(coef\2, f), b=tanEval(coef-coef\2, f));

test([[44,1/57],[7,1/239],[-12,1/682],[24,1/12943]]);

test([[88,1/172],[51,1/239],[32,1/682],[44,1/5357],[68,1/12943]]);

{{out}}

<pre>OK

OK

Error: [[88, 1/172], [51, 1/239], [32, 1/682], [44, 1/5357], [68, 1/12944]]</pre>

=={{header|Perl}}==

 

sub taneval {

test([44,'1/57'],[7,'1/239'],[-12,'1/682'],[24,'1/12943']);

test([88,'1/172'],[51,'1/239'],[32,'1/682'],[44,'1/5357'],[68,'1/12943']);

{{out}}

<pre> OK ([1 1/2] [1 1/3])

OK ([88 1/172] [51 1/239] [32 1/682] [44 1/5357] [68 1/12943])

Error ([88 1/172] [51 1/239] [32 1/682] [44 1/5357] [68 1/12944])</pre>

=={{header|Phix}}==

{{out}}

<pre>

 

===Using proper fractions===

{{out}}

<pre>

</pre>

=={{header|Python}}==

This example parses the [http://rosettacode.org/mw/index.php?title=Check_Machin-like_formulas&oldid=146749 original] equations to form an intermediate representation then does the checks.<br>

Function tans and tanEval are translations of the Haskell functions of the same names.

from fractions import Fraction

from pprint import pprint as pp

for machin, eqn in zip(machins, equationtext.split('\n')):

ans = tans(machin)

 

{{out}}

 

'''Note:''' the [http://kodos.sourceforge.net/ Kodos] tool was used in developing the regular expression.

=={{header|R}}==

#lang R

library(Rmpfr)

# function for checking identity of tan of expression and 1, making use of high precision division operator %:%

tanident_1 <- function(x) identical(round(tan(eval(parse(text = gsub("/", "%:%", deparse(substitute(x)))))), (prec/10)), mpfr(1, prec))

 

{{out}}

tanident_1( 1*atan(1/2) + 1*atan(1/3) )

## [1] TRUE

tanident_1(88*atan(1/172) + 51*atan(1/239) + 32*atan(1/682) + 44*atan(1/5357) + 68*atan(1/12944))

## [1] FALSE

=={{header|Racket}}==

#lang racket

(define (reduce e)

(displayln "The incorrect formula reduces to:")

(reduce wrong-formula)

Output:

Do all correct formulas reduce to 1?

#t

The incorrect formula reduces to:

1009288018000944050967896710431587186456256928584351786643498522649995492271475761189348270710224618853590682465929080006511691833816436374107451368838065354726517908250456341991684635768915704374493675498637876700129004484434187627909285979251682006538817341793224963346197503893270875008524149334251672855130857035205217929335932890740051319216343365800342290782260673215928499123722781078448297609548233999010983373327601187505623621602789012550584784738082074783523787011976757247516095289966708782862528690942242793667539020699840402353522108223/1009288837315638583415701528780402795721935641614456853534313491853293025565940011104051964874275710024625850092154664245109626053906509780125743180758231049920425664246286578958307532545458843067352531217230461290763258378749459637420702619029075083089762088232401888676895047947363883809724322868121990870409574061477638203859217672620508200713073485398199091153535700094640095900731630771349477187594074169815106104524371099618096164871416282464532355211521113449237814080332335526420331468258917484010722587072087349909684004660371264507984339711

=={{header|Raku}}==

(formerly Perl 6)

 

{{trans|Perl}}

return 0 if $coef == 0;

return $f if $coef == 1;

[[88,1/172], [51,1/239], [32,1/682], [44,1/5357], [68,1/12943]],

[[88,1/172], [51,1/239], [32,1/682], [44,1/5357], [68,1/21944]]

{{out}}

<pre> OK ([1 1/2] [1 1/3])

OK ([88 1/172] [51 1/239] [32 1/682] [44 1/5357] [68 1/12943])

Error ([88 1/172] [51 1/239] [32 1/682] [44 1/5357] [68 1/21944])</pre>

=={{header|REXX}}==

Note: &nbsp; REXX doesn't have many high─order math functions, &nbsp; so a few of them are included here.

 

An extra formula was added to stress test the near exactness of a value.

@.=; pi= pi(); numeric digits( length(pi) ) - length(.); numeric fuzz 3

say center(' computing with ' digits() " decimal digits ", 110, '═')

numeric digits; parse value format(x,2,1,,0) 'E0' with g 'E' _ .; g=g *.5'e'_ % 2

do j=0 while h>9; m.j=h; h=h%2+1; end /*j*/

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

bad: pi/4 = 88*atan(1/172) + 51*atan(1/239) + 32*atan(1/682) + 44*atan(1/5357) + 68 *atan(1/12944)

bad: pi/4 = 88*atan(1/172) + 51*atan(1/239) + 32*atan(1/682) + 44*atan(1/5357) + 67.9999999994*atan(1/12943)

</pre>

 

=={{header|Seed7}}==

include "bigint.s7i";

include "bigrat.s7i";

writeln;

end for;

 

{{out}}

=={{header|Sidef}}==

{{trans|Python}}

pi/4 = arctan(1/2) + arctan(1/3)

pi/4 = 2*arctan(1/3) + arctan(1/7)

var ans = tans(machin)

printf("%5s: %s\n", (ans == 1 ? 'OK' : 'ERROR'), eqn)

{{out}}

<pre>

ERROR: pi/4 = 88*arctan(1/172) + 51*arctan(1/239) + 32*arctan(1/682) + 44*arctan(1/5357) + 68*arctan(1/12944)

</pre>

=={{header|Tcl}}==

 

# Compute tan(atan(p)+atan(q)) using rationals

puts "No! '$formula' not true"

}

{{out}}

<pre>

No! 'pi/4 = 88*arctan(1/172) + 51*arctan(1/239) + 32*arctan(1/682) + 44*arctan(1/5357) + 68*arctan(1/12944)' not true

</pre>

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

We already have a BigRat class so we use that.

 

/** represents a term of the form: c * atan(n / d) */

for (i in 1...terms.count) System.write(terms[i])

System.print(")")

 

{{out}}

 

=={{header|XPL0}}==

int Number(18); \numbers from equations

def LF=$0A; \ASCII line feed (end-of-line character)

repeat ChOut(0, SS(0)); SS:= SS+1 until SS(0)=LF; ChOut(0, LF); \show equation

];

 

{{out}}