Imaginary base numbers: Difference between revisions

{{trans|Python}}

 

V denom = c.real * c.real + c.imag * c.imag

R Complex(c.real / denom, -c.imag / denom)

print(‘#8 -> #8 -> #8’.format(c1, qi, c2))

 

 

{{out}}

=={{header|C}}==

{{trans|C++}}

#include <stdio.h>

#include <string.h>

 

return 0;

{{out}}

<pre>( 1 + 0i) -> 1 -> ( 1 + 0i) ( -1 + -0i) -> 103 -> ( -1 + 0i)

 

=={{header|C sharp|C#}}==

using System.Linq;

using System.Text;

}

}

{{out}}

<pre> 1 -> 1 -> 1 -1 -> 103 -> -1

=={{header|C++}}==

{{trans|C#}}

#include <complex>

#include <iomanip>

 

return 0;

{{out}}

<pre> (1,0) -> 1 -> (1,0) (-1,-0) -> 103 -> (-1,0)

=={{header|D}}==

{{trans|Kotlin}}

import std.array;

import std.complex;

writefln("%4si -> %8s -> %4si", c1.im, qi, c2.im);

}

{{out}}

<pre> 1 -> 1 -> 1 -1 -> 103 -> -1

{{trans|Kotlin}}

... though a bit shorter as Go has support for complex numbers built into the language.

 

import (

fmt.Printf("%3.0fi -> %8s -> %3.0fi\n", imag(c1), qi, imag(c2))

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.Complex (Complex (..), imagPart, realPart)

import Data.List (delete, elemIndex)

main =

putStrLn (fromComplexToQI (35 :+ 23))

{{out}}

<pre>121003.2

Implementation:

 

ibdec=: {{

0j2 ibdec y

frac,~(}.~0 i.~_1}.'0'=]) }:,hfd|:0 1|."0 1 seq re,im

}}"0

 

This ibdec can decode numbers from complex bases up to 0j6, but this ibenc can only represent digits in complex bases up to 0j4.

Examples:

 

(ibenc i:16),.' ',.ibenc j.i:16

1030000 2000

0j4 ibdec 0j4 ibenc 42

42

 

=={{header|Java}}==

{{trans|Kotlin}}

private static class Complex {

private Double real, imag;

}

}

{{out}}

<pre> 1 -> 1 -> 1 -1 -> 103 -> -1

=={{header|Julia}}==

{{trans|C#}}

 

function inbase4(charvec::Vector)

 

testquim()

1 -> 1 -> 1 -1 -> 103 -> -1

2 -> 2 -> 2 -2 -> 102 -> -2

 

As the JDK lacks a complex number class, I've included a very basic one in the program.

 

import kotlin.math.ceil

println(fmt.format(c1, qi, c2))

}

 

{{out}}

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

{{trans|C#}}

FROM FormatString IMPORT FormatString;

FROM RealMath IMPORT round;

 

ReadChar

{{out}}

<pre>1 -> 1 -> 1 -1 -> 103 -> -1

{{trans|Kotlin}}

This is a fairly faithful translation of the Kotlin program except that we had not to define a Complex type as Nim provides the module “complex” in its standard library. We had only to define a function “toString” for the “Complex[float]” type, function to use in place of “$” in order to get a more pleasant output.

 

const

qi = c1.toQuaterImaginary

c2 = qi.toComplex

 

{{out}}

{{trans|Raku}}

{{libheader|ntheory}}

use warnings;

use feature 'say';

say '';

say 'base( 6i): 31432.6219135802-2898.5266203704*i => ' .

{{out}}

<pre>base( 2i): 0 => 0 => 0

=={{header|Phix}}==

{{trans|Sidef}}

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

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

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

Matches the output of Sidef and Raku, except for the final line:

=={{header|Python}}==

{{trans|C++}}

import re

 

 

print "done"

{{out}}

<pre> (1+0j) -> 1 -> (1+0j) (-1-0j) -> 103 -> (-1+0j)

Implements minimum, extra kudos and stretch goals.

 

return '0' unless $num;

my $value = $num;

printf "%33s.&base\(%2si\) = %-11s : %13s.&parse-base\(%2si\) = %s\n",

$v, $r.im, $ibase, "'$ibase'", $r.im, $ibase.&parse-base($r).round(1e-10).narrow;

{{out}}

<pre> 0.&base( 2i) = 0 : '0'.&parse-base( 2i) = 0

Doing pretty much the same tests as the explicit version.

 

 

# TESTING

printf "%33s.&to-base\(%3si\) = %-11s : %13s.&from-base\(%3si\) = %s\n",

$v, $r.im, $ibase, "'$ibase'", $r.im, $ibase.&from-base($r).round(1e-10).narrow;

{{out}}

<pre> 0.&to-base( 2i) = 0 : '0'.&from-base( 2i) = 0

{{works with|Ruby|2.3}}

'''The Functions'''

 

def base2i_decode(qi)

value.concat(odd ? '.2' : '.0') if frac

return value

'''The Task'''

 

class Integer

puts

end

{{out}}

Conversions given in the task.

=={{header|Sidef}}==

{{trans|Raku}}

num || return '0'

 

printf("base(%20s, %2si) = %-10s : parse_base(%12s, %2si) = %s\n",

v, r.im, ibase, "'#{ibase}'", r.im, parse_base(ibase, r).round(-8))

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre> 1 -> 1 -> 1 -1 -> 103 -> -1

{{libheader|Wren-complex}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

 

c2 = qi.toComplex

Fmt.print(fmt, imagOnly.call(c1), qi, imagOnly.call(c2))

 

{{out}}