Minkowski question-mark function: Difference between revisions

{{trans|Python}}

 

 

F minkowski(x) -> Float

print(‘#2.16 #2.16’.format(minkowski(0.5 * (1 + sqrt(5))), 5.0 / 3.0))

print(‘#2.16 #2.16’.format(minkowski_inv(-5.0 / 9.0), (sqrt(13) - 7) / 6))

 

{{out}}

=={{header|Factor}}==

{{works with|Factor|0.99 2020-08-14}}

math.continued-fractions math.functions math.parser

math.statistics sequences sequences.extras splitting.monotonic

phi ? 5 3 /f compare

-5/9 ?⁻¹ 13 sqrt 7 - 6 /f compare

{{out}}

<pre>

=={{header|FreeBASIC}}==

 

 

function minkowski( x as double ) as double

print minkowski_inv( -5./9 ), (sqr(13)-7)/6

print minkowski(minkowski_inv(0.718281828)), minkowski_inv(minkowski(0.1213141516171819))

{{out}}

<pre> 1.666666666669698 1.666666666666667

=={{header|Go}}==

{{trans|FreeBASIC}}

 

import (

fmt.Printf("%19.16f %19.16f\n", minkowski(minkowskiInv(0.718281828)),

minkowskiInv(minkowski(0.1213141516171819)))

 

{{out}}

This recursive definition can be implemented as lazy corecursion, i.e. by generating two infinite binary trees: '''mediant'''-based Stern-Brocot tree, containing all rationals, and '''mean'''-based tree with corresponding values of Minkowsky ?-function. There is one-to-one correspondence between these two trees so both {{math|?(x)}} and {{math|?^-1(x)}} may be implemented as mapping between them. For details see the paper [[https://habr.com/ru/post/591949/]] (in Russian).

 

import Data.Ratio

import Data.List

questionMarkF, invQuestionMarkF :: Double -> Double

questionMarkF = sternBrocotF ==> minkowskiF

 

<pre>λ> mapM_ print $ take 4 $ levels farey

Implementation:

 

 

minkowski=: {{

end.

(+%)/(<.y),cf

 

That said, note that this algorithm introduces significant numeric instability for √7 divided by 3:

 

 

I see this same instability using the python implementation and appending:

 

"{:19.16f} {:19.16f}".format(

minkowski(minkowski_inv(4.04145188432738056)),

minkowski_inv(minkowski(4.04145188432738056)),

)

 

Using an exact fraction for 4.04145188432738056 and bumping the iteration count from 52 up to 200 changes that difference to 1.43622e_12.

=={{header|Julia}}==

{{trans|FreeBASIC}}

p = Int(floor(x))

(x > 1 || x < 0) && return p + minkowski(x)

println(" ", minkowski(minkowski_inv(0.718281828)), " ",

minkowski_inv(minkowski(0.1213141516171819)))

<pre>

1.6666666666696983 1.6666666666666667

 

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

InverseMinkowskiQuestionMark[val_] := Module[{x}, (x /. FindRoot[MinkowskiQuestionMark[x] == val, {x, Floor[val], Ceiling[val]}])]

MinkowskiQuestionMark[GoldenRatio]

InverseMinkowskiQuestionMark[-5/9] // RootApproximant

MinkowskiQuestionMark[InverseMinkowskiQuestionMark[0.1213141516171819]]

{{out}}

<pre>5/3

=={{header|Nim}}==

{{trans|Go}}

 

const MaxIter = 151

echo &"{minkowskiInv(-5/9):19.16f}, {(sqrt(13.0)-7)/6:19.16f}"

echo &"{minkowski(minkowskiInv(0.718281828)):19.16f}, " &

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

printf "%19.16f %19.16f\n", minkowski(0.5*(1 + sqrt(5))), 5/3;

printf "%19.16f %19.16f\n", minkowskiInv(-5/9), (sqrt(13)-7)/6;

{{out}}

<pre> 1.6666666666696983 1.6666666666666667

=={{header|Phix}}==

{{trans|FreeBASIC}}

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

<span style="color: #008080;">constant</span> <span style="color: #000000;">MAXITER</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">151</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%20.16f %20.16f\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">minkowski</span><span style="color: #0000FF;">(</span><span style="color: #000000;">minkowski_inv</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0.718281828</span><span style="color: #0000FF;">)),</span>

<span style="color: #000000;">minkowski_inv</span><span style="color: #0000FF;">(</span><span style="color: #000000;">minkowski</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0.1213141516171819</span><span style="color: #0000FF;">))})</span>

{{out}}

<pre>

=={{header|Python}}==

{{trans|Go}}

 

MAXITER = 151

)

)

 

{{out}}

=={{header|Raku}}==

{{trans|Go}}

 

my \MAXITER = 151;

printf "%19.16f %19.16f\n", minkowskiInv(-5/9), (13.sqrt-7)/6;

printf "%19.16f %19.16f\n", minkowski(minkowskiInv(0.718281828)),

{{out}}

<pre> 1.6666666666696983 1.6666666666666667

{{trans|FreeBASIC}}

{{trans|Phix}}

numeric digits 40 /*use enough dec. digits for precision.*/

say fmt( mink( 0.5 * (1+sqrt(5) ) ) ) fmt( 5/3 )

numeric form; m.=9; 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 inputs:}}

<pre>

{{trans|FreeBASIC}}

{{libheader|Wren-fmt}}

 

var MAXITER = 151

Fmt.print("$17.14f $17.14f", minkowskiInv.call(-5/9), (13.sqrt - 7)/6)

Fmt.print("$17.14f $17.14f", minkowski.call(minkowskiInv.call(0.718281828)),

 

{{out}}