Imaginary base numbers: Difference between revisions
Content added Content deleted
(Added Go) |
(Added C#) |
||
Line 310: | Line 310: | ||
</tr> |
</tr> |
||
</table> |
</table> |
||
=={{header|C#|C sharp}}== |
|||
<lang csharp>using System; |
|||
using System.Linq; |
|||
using System.Text; |
|||
namespace ImaginaryBaseNumbers { |
|||
class Complex { |
|||
private double real, imag; |
|||
public Complex(int r, int i) { |
|||
real = r; |
|||
imag = i; |
|||
} |
|||
public Complex(double r, double i) { |
|||
real = r; |
|||
imag = i; |
|||
} |
|||
public static Complex operator -(Complex self) => |
|||
new Complex(-self.real, -self.imag); |
|||
public static Complex operator +(Complex rhs, Complex lhs) => |
|||
new Complex(rhs.real + lhs.real, rhs.imag + lhs.imag); |
|||
public static Complex operator -(Complex rhs, Complex lhs) => |
|||
new Complex(rhs.real - lhs.real, rhs.imag - lhs.imag); |
|||
public static Complex operator *(Complex rhs, Complex lhs) => |
|||
new Complex( |
|||
rhs.real * lhs.real - rhs.imag * lhs.imag, |
|||
rhs.real * lhs.imag + rhs.imag * lhs.real |
|||
); |
|||
public static Complex operator *(Complex rhs, double lhs) => |
|||
new Complex(rhs.real * lhs, rhs.imag * lhs); |
|||
public static Complex operator /(Complex rhs, Complex lhs) => |
|||
rhs * lhs.Inv(); |
|||
public Complex Inv() { |
|||
double denom = real * real + imag * imag; |
|||
return new Complex(real / denom, -imag / denom); |
|||
} |
|||
public QuaterImaginary ToQuaterImaginary() { |
|||
if (real == 0.0 && imag == 0.0) return new QuaterImaginary("0"); |
|||
int re = (int)real; |
|||
int im = (int)imag; |
|||
int fi = -1; |
|||
StringBuilder sb = new StringBuilder(); |
|||
while (re != 0) { |
|||
int rem = re % -4; |
|||
re /= -4; |
|||
if (rem < 0) { |
|||
rem = 4 + rem; |
|||
re++; |
|||
} |
|||
sb.Append(rem); |
|||
sb.Append(0); |
|||
} |
|||
if (im != 0) { |
|||
double f = (new Complex(0.0, imag) / new Complex(0.0, 2.0)).real; |
|||
im = (int)Math.Ceiling(f); |
|||
f = -4.0 * (f - im); |
|||
int index = 1; |
|||
while (im != 0) { |
|||
int rem = im % -4; |
|||
im /= -4; |
|||
if (rem < 0) { |
|||
rem = 4 + rem; |
|||
im++; |
|||
} |
|||
if (index < sb.Length) { |
|||
sb[index] = (char)(rem + 48); |
|||
} else { |
|||
sb.Append(0); |
|||
sb.Append(rem); |
|||
} |
|||
index += 2; |
|||
} |
|||
fi = (int)f; |
|||
} |
|||
string reverse = new string(sb.ToString().Reverse().ToArray()); |
|||
sb.Length = 0; |
|||
sb.Append(reverse); |
|||
if (fi != -1) sb.AppendFormat(".{0}", fi); |
|||
string s = sb.ToString().TrimStart('0'); |
|||
if (s[0] == '.') s = "0" + s; |
|||
return new QuaterImaginary(s); |
|||
} |
|||
public override string ToString() { |
|||
double real2 = (real == -0.0) ? 0.0 : real; // get rid of negative zero |
|||
double imag2 = (imag == -0.0) ? 0.0 : imag; // ditto |
|||
if (imag2 == 0.0) { |
|||
return string.Format("{0}", real2); |
|||
} |
|||
if (real2 == 0.0) { |
|||
return string.Format("{0}i", imag2); |
|||
} |
|||
if (imag2 > 0.0) { |
|||
return string.Format("{0} + {1}i", real2, imag2); |
|||
} |
|||
return string.Format("{0} - {1}i", real2, -imag2); |
|||
} |
|||
} |
|||
class QuaterImaginary { |
|||
internal static Complex twoI = new Complex(0.0, 2.0); |
|||
internal static Complex invTwoI = twoI.Inv(); |
|||
private string b2i; |
|||
public QuaterImaginary(string b2i) { |
|||
if (b2i == "" || !b2i.All(c => "0123.".IndexOf(c) > -1) || b2i.Count(c => c == '.') > 1) { |
|||
throw new Exception("Invalid Base 2i number"); |
|||
} |
|||
this.b2i = b2i; |
|||
} |
|||
public Complex ToComplex() { |
|||
int pointPos = b2i.IndexOf("."); |
|||
int posLen = (pointPos != -1) ? pointPos : b2i.Length; |
|||
Complex sum = new Complex(0.0, 0.0); |
|||
Complex prod = new Complex(1.0, 0.0); |
|||
for (int j = 0; j < posLen; j++) { |
|||
double k = (b2i[posLen - 1 - j] - '0'); |
|||
if (k > 0.0) { |
|||
sum += prod * k; |
|||
} |
|||
prod *= twoI; |
|||
} |
|||
if (pointPos != -1) { |
|||
prod = invTwoI; |
|||
for (int j = posLen + 1; j < b2i.Length; j++) { |
|||
double k = (b2i[j] - '0'); |
|||
if (k > 0.0) { |
|||
sum += prod * k; |
|||
} |
|||
prod *= invTwoI; |
|||
} |
|||
} |
|||
return sum; |
|||
} |
|||
public override string ToString() { |
|||
return b2i; |
|||
} |
|||
} |
|||
class Program { |
|||
static void Main(string[] args) { |
|||
for (int i = 1; i <= 16; i++) { |
|||
Complex c1 = new Complex(i, 0); |
|||
QuaterImaginary qi = c1.ToQuaterImaginary(); |
|||
Complex c2 = qi.ToComplex(); |
|||
Console.Write("{0,4} -> {1,8} -> {2,4} ", c1, qi, c2); |
|||
c1 = -c1; |
|||
qi = c1.ToQuaterImaginary(); |
|||
c2 = qi.ToComplex(); |
|||
Console.WriteLine("{0,4} -> {1,8} -> {2,4}", c1, qi, c2); |
|||
} |
|||
Console.WriteLine(); |
|||
for (int i = 1; i <= 16; i++) { |
|||
Complex c1 = new Complex(0, i); |
|||
QuaterImaginary qi = c1.ToQuaterImaginary(); |
|||
Complex c2 = qi.ToComplex(); |
|||
Console.Write("{0,4} -> {1,8} -> {2,4} ", c1, qi, c2); |
|||
c1 = -c1; |
|||
qi = c1.ToQuaterImaginary(); |
|||
c2 = qi.ToComplex(); |
|||
Console.WriteLine("{0,4} -> {1,8} -> {2,4}", c1, qi, c2); |
|||
} |
|||
} |
|||
} |
|||
}</lang> |
|||
{{out}} |
|||
<pre> 1 -> 1 -> 1 -1 -> 103 -> -1 |
|||
2 -> 2 -> 2 -2 -> 102 -> -2 |
|||
3 -> 3 -> 3 -3 -> 101 -> -3 |
|||
4 -> 10300 -> 4 -4 -> 100 -> -4 |
|||
5 -> 10301 -> 5 -5 -> 203 -> -5 |
|||
6 -> 10302 -> 6 -6 -> 202 -> -6 |
|||
7 -> 10303 -> 7 -7 -> 201 -> -7 |
|||
8 -> 10200 -> 8 -8 -> 200 -> -8 |
|||
9 -> 10201 -> 9 -9 -> 303 -> -9 |
|||
10 -> 10202 -> 10 -10 -> 302 -> -10 |
|||
11 -> 10203 -> 11 -11 -> 301 -> -11 |
|||
12 -> 10100 -> 12 -12 -> 300 -> -12 |
|||
13 -> 10101 -> 13 -13 -> 1030003 -> -13 |
|||
14 -> 10102 -> 14 -14 -> 1030002 -> -14 |
|||
15 -> 10103 -> 15 -15 -> 1030001 -> -15 |
|||
16 -> 10000 -> 16 -16 -> 1030000 -> -16 |
|||
1i -> 10.2 -> 1i -1i -> 0.2 -> -1i |
|||
2i -> 10.0 -> 2i -2i -> 1030.0 -> -2i |
|||
3i -> 20.2 -> 3i -3i -> 1030.2 -> -3i |
|||
4i -> 20.0 -> 4i -4i -> 1020.0 -> -4i |
|||
5i -> 30.2 -> 5i -5i -> 1020.2 -> -5i |
|||
6i -> 30.0 -> 6i -6i -> 1010.0 -> -6i |
|||
7i -> 103000.2 -> 7i -7i -> 1010.2 -> -7i |
|||
8i -> 103000.0 -> 8i -8i -> 1000.0 -> -8i |
|||
9i -> 103010.2 -> 9i -9i -> 1000.2 -> -9i |
|||
10i -> 103010.0 -> 10i -10i -> 2030.0 -> -10i |
|||
11i -> 103020.2 -> 11i -11i -> 2030.2 -> -11i |
|||
12i -> 103020.0 -> 12i -12i -> 2020.0 -> -12i |
|||
13i -> 103030.2 -> 13i -13i -> 2020.2 -> -13i |
|||
14i -> 103030.0 -> 14i -14i -> 2010.0 -> -14i |
|||
15i -> 102000.2 -> 15i -15i -> 2010.2 -> -15i |
|||
16i -> 102000.0 -> 16i -16i -> 2000.0 -> -16i</pre> |
|||
=={{header|D}}== |
=={{header|D}}== |