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)

 

T QuaterImaginary

String b2i

 

I k > 0

sum += prod * k

I pointPos != -1

L(j) posLen + 1 .< .b2i.len

V k = Int(.b2i[j])

I k > 0

sum += prod * k

R sum

 

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

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>

 

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

 

class QuaterImaginary {

c2 = qi.toComplex

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

 

{{out}}