Imaginary base numbers: Difference between revisions

</tr>

</table>

 

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

15i -> 102000.2 -> 15i -15i -> 2010.2 -> -15i

16i -> 102000.0 -> 16i -16i -> 2000.0 -> -16i</pre>

 

=={{header|Go}}==

{{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.Maybe (fromMaybe)

base :: Complex Float

base = 0 :+ 2

quotRemPositive :: Int -> Int -> (Int, Int)

quotRemPositive a b

where

(q, r) = quotRem a b

digitToIntQI :: Char -> Int

digitToIntQI c

| isDigit c = digitToInt c

| otherwise = ord c - ord 'a' + 10

shiftRight :: String -> String

shiftRight n

| l == '0' = h

where

(l, h) = (last n, init n)

intToDigitQI :: Int -> Char

intToDigitQI i

| i `elem` [0 .. 9] = intToDigit i

| otherwise = chr (i - 10 + ord 'a')

fromQItoComplex :: String -> Complex Float -> Complex Float

fromQItoComplex num b =

let dot = fromMaybe (length num) (elemIndex '.' num)

euclidEr :: Int -> Int -> [Int] -> [Int]

euclidEr a b l

| a == 0 = l

| otherwise =

fromIntToQI :: Int -> [Int]

fromIntToQI 0 = [0]

getCuid :: Complex Int -> Int

getCuid c = imagPart c * floor (imagPart (-base))

qizip :: Complex Int -> [Int]

qizip c =

fromComplexToQI :: Complex Int -> String

fromComplexToQI = shiftRight . fmap intToDigitQI . qizip

main :: IO ()

{{out}}

With base = 8i (you may choose any base):

0.0 :+ 7.75</pre>

 

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

15i -> 102000.2 -> 15i -15i -> 2010.2 -> -15i

16i -> 102000.0 -> 16i -16i -> 2000.0 -> -16i</pre>

 

=={{header|Perl}}==

{{trans|Raku}}

{{libheader|ntheory}}

use warnings;

use feature 'say';

$_ //= '' for $re_fr, $im_fr;

 

my $fraction = zip $im_fr, $re_fr;

$fraction eq 0 ? "$whole" : "$whole.$fraction"

say '';

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

{{out}}

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

=={{header|Phix}}==

{{trans|Sidef}}

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

31433.3487654321-2902.4480452675i.&to-base( 6i) = PERL6.ROCKS : 'PERL6.ROCKS'.&from-base( 6i) = 31433.3487654321-2902.4480452675i

-3544.29+26541.468i.&to-base(-10i) = Raku.FTW : 'Raku.FTW'.&from-base(-10i) = -3544.29+26541.468i</pre>

 

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

15i -> 102000.2 -> 15i -15i -> 2010.2 -> -15i

16i -> 102000.0 -> 16i -16i -> 2000.0 -> -16i</pre>