Check Machin-like formulas: Difference between revisions

: <math>{\pi\over4} = 88 \arctan{1\over172} + 51 \arctan{1\over239} + 32 \arctan{1\over682} + 44 \arctan{1\over5357} + 68 \arctan{1\over12943}</math>

 

 

: <math>{\pi\over4} = 88 \arctan{1\over172} + 51 \arctan{1\over239} + 32 \arctan{1\over682} + 44 \arctan{1\over5357} + 68 \arctan{1\over12944}</math>

 

<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

 

 

 

 

 

 

{{out}}

=={{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|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|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>

 

 

{{out}}

=={{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>

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|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|REXX}}==

@.10= 'pi/4 = 8*atan(1/10) - atan(1/239) - 4*atan(1/515)'

@.11= 'pi/4 = 12*atan(1/18) + 8*atan(1/57) - 5*atan(1/239)'

@.14= 'pi/4 = 22*atan(1/38) + 17*atan(7/601) + 10*atan(7/8149)'

@.15= 'pi/4 = 44*atan(1/57) + 7*atan(1/239) - 12*atan(1/682) + 24*atan(1/12943)'

 

do j=1 while @.j\=='' /*evaluate each "Machin─like" formulas.*/

end /*j*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

Atan: procedure; arg x; if abs(x)=1 then return pi()/4*sign(x); return Asin(x/sqrt(1+x*x))

/*──────────────────────────────────────────────────────────────────────────────────────*/

if a>=sqrt(2)*.5 then return sign(x) * Acos( sqrt(1 - aa) )

do j=2 by 2 until p=z; p=z; o=o*aa*(j-1)/j; z=z+o/(j+1); end /*j*/; return z

sqrt: procedure; parse arg x; if x=0 then return 0; d=digits(); m.=9; h=d+6; numeric form

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

<pre>

OK: pi/4 = atan(1/2) + atan(1/3)

OK: pi/4 = 2*atan(1/3) + atan(1/7)

OK: pi/4 = 22*atan(1/38) + 17*atan(7/601) + 10*atan(7/8149)

OK: pi/4 = 44*atan(1/57) + 7*atan(1/239) - 12*atan(1/682) + 24*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)

 

func parse_eqn(equation) {

(?: ( \d+ ) \s* \*)?

 

gather {

take([

[+1, -1][sign == '-'] * (mult ? Num(mult) : 1),

])

}

}

}

 

func tanEval(coef, f) {

var (a, b) = (tanEval(ca, f), tanEval(cb, f))

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

}

 

func tans(xs) {

var (a, b) = (tans(aa), tans(bb))

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

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>

Yes! 'pi/4 = 88*arctan(1/172) + 51*arctan(1/239) + 32*arctan(1/682) + 44*arctan(1/5357) + 68*arctan(1/12943)' is true

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|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}}