464 lines
7.1 KiB
D
464 lines
7.1 KiB
D
// RUNNABLE_PHOBOS_TEST
|
|
// PERMUTE_ARGS:
|
|
|
|
import std.stdio;
|
|
import std.math;
|
|
import core.stdc.stdio;
|
|
|
|
/***************************************/
|
|
|
|
void test1()
|
|
{
|
|
creal c = 3.0 + 4.0i;
|
|
c = sqrt(c);
|
|
printf("re = %Lg, im = %Lg\n", c.re, c.im);
|
|
assert(c.re == 2.0);
|
|
assert(c.im == 1.0);
|
|
|
|
float f = sqrt(25.0f);
|
|
assert(f == 5.0);
|
|
double d = sqrt(4.0);
|
|
assert(d == 2.0);
|
|
real r = sqrt(9.0L);
|
|
assert(r == 3.0);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
ireal f2() { return 1i; }
|
|
|
|
void test2()
|
|
{
|
|
creal v = 0+0i;
|
|
|
|
v += f2();
|
|
assert(v == 0 + 1i);
|
|
|
|
v = v + f2();
|
|
assert(v == 0 + 2i);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
cdouble[1] a3;
|
|
cdouble[1] b3;
|
|
|
|
cdouble[] concat3() {
|
|
return a3~b3;
|
|
}
|
|
|
|
void test3()
|
|
{
|
|
a3[]=0.5+1.0i;
|
|
b3[]=0.5+3.0i;
|
|
|
|
cdouble[] arr=concat3();
|
|
|
|
assert(arr.length==2);
|
|
assert(arr[0]==0.5+1.0i);
|
|
assert(arr[1]==0.5+3.0i);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
creal[1] a4;
|
|
creal[1] b4;
|
|
|
|
creal[] concat4() {
|
|
return a4~b4;
|
|
}
|
|
|
|
void test4()
|
|
{
|
|
a4[]=0.5+1.0i;
|
|
b4[]=0.5+3.0i;
|
|
|
|
creal[] arr=concat4();
|
|
|
|
assert(arr.length==2);
|
|
assert(arr[0]==0.5+1.0i);
|
|
assert(arr[1]==0.5+3.0i);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void test5()
|
|
{
|
|
ifloat i=1.0fi;
|
|
// i += 2.2;
|
|
// assert(i == 1i);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void test6()
|
|
{
|
|
float i=1.0f;
|
|
// i /= 2.2fi;
|
|
// assert(i == 0);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void test7()
|
|
{
|
|
creal x=1.0i+2.0;
|
|
creal[] arr;
|
|
|
|
arr = arr ~ x;
|
|
assert(arr.length==1);
|
|
assert(arr[0]==1.0i+2.0);
|
|
|
|
x=0.0i+5.0;
|
|
assert(arr[0]==1.0i+2.0);
|
|
}
|
|
|
|
/****************************************/
|
|
|
|
creal[1] a8;
|
|
creal[1] b8;
|
|
|
|
creal[] concat8() {
|
|
return a8 ~ b8;
|
|
}
|
|
|
|
void test8()
|
|
{
|
|
a8[]=0.5L+1.0Li;
|
|
b8[]=0.5L+3.0Li;
|
|
|
|
creal[] arr=concat8();
|
|
|
|
assert(arr.length==2);
|
|
assert(arr[0]==0.5L+1.0Li);
|
|
assert(arr[1]==0.5L+3.0Li);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
creal[1] a9;
|
|
creal[1] b9;
|
|
|
|
creal[] concat9() {
|
|
return a9~b9;
|
|
}
|
|
|
|
void test9()
|
|
{
|
|
a9[]=0.5L+1.0Li;
|
|
b9[]=0.5L+3.0Li;
|
|
|
|
creal[] arr=concat9();
|
|
|
|
assert(arr.length==2);
|
|
assert(arr[0]==0.5L+1.0Li);
|
|
assert(arr[1]==0.5L+3.0Li);
|
|
}
|
|
|
|
|
|
/***************************************/
|
|
|
|
void test10()
|
|
{
|
|
ifloat a = 1.0i;
|
|
assert(a.im == 1.0);
|
|
|
|
const ifloat b = 2.0i;
|
|
static assert(b.im == 2.0); // FAIL
|
|
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void test11()
|
|
{
|
|
real r = real.nan;
|
|
assert( r!=0 );
|
|
if (r==0) assert(0);
|
|
|
|
ireal ir = ireal.nan;
|
|
assert( ir!=0 );
|
|
assert( ir!=0i );
|
|
if (ir==0) assert(0);
|
|
if (ir==0i) assert(0);
|
|
|
|
creal cr = creal.nan;
|
|
assert( cr!=0 );
|
|
assert( cr!=0i );
|
|
if (cr==0) assert(0);
|
|
if (cr==0i) assert(0);
|
|
|
|
double d = double.nan;
|
|
assert( d!=0 );
|
|
if (d==0) assert(0);
|
|
|
|
idouble id = idouble.nan;
|
|
assert( id!=0 );
|
|
assert( id!=0i );
|
|
if (id==0) assert(0);
|
|
if (id==0i) assert(0);
|
|
|
|
cdouble cd = cdouble.nan;
|
|
assert( cd!=0 );
|
|
assert( cd!=0i );
|
|
if (cd==0) assert(0);
|
|
if (cd==0i) assert(0);
|
|
|
|
float f = float.nan;
|
|
assert( f!=0 );
|
|
if (f==0) assert(0);
|
|
|
|
ifloat ifx = ifloat.nan;
|
|
assert( ifx!=0 );
|
|
assert( ifx!=0i );
|
|
if (ifx==0) assert(0);
|
|
if (ifx==0i) assert(0);
|
|
|
|
cfloat cf = cfloat.nan;
|
|
assert( cf!=0 );
|
|
assert( cf!=0i );
|
|
if (cf==0) assert(0);
|
|
if (cf==0i) assert(0);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void test12()
|
|
{
|
|
real x = 3;
|
|
creal a = (2 + 4i) % 3;
|
|
writeln(a);
|
|
assert(a == 2 + 1i);
|
|
|
|
creal b = (2 + 4i) % x;
|
|
writeln(b);
|
|
assert(b == a);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void test13()
|
|
{
|
|
ireal a = 5i;
|
|
ireal b = a % 2;
|
|
writeln(b);
|
|
assert(b == 1i);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
cdouble inv( cdouble expr )
|
|
{
|
|
return (1.0 + 0.0i) / expr;
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void test14()
|
|
{
|
|
cfloat c;
|
|
cfloat d;
|
|
assert(c != d);
|
|
|
|
cdouble e;
|
|
cdouble f;
|
|
assert(e != f);
|
|
|
|
creal g;
|
|
creal h;
|
|
assert(g != h);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void test7581()
|
|
{
|
|
cfloat a() { return cfloat.nan; }
|
|
assert(a() != 0);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
float f() { return 1.0f; }
|
|
ifloat i() { return 1.0fi; }
|
|
|
|
void test7594()
|
|
{
|
|
assert(f() + i() == 1.0f + 1.0fi);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
cdouble conv(cfloat a)
|
|
{
|
|
return a;
|
|
}
|
|
|
|
void test7593()
|
|
{
|
|
assert(conv(1.0f+1.0fi) == 1.0+1.0i);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
cfloat get() { return cfloat.nan; }
|
|
|
|
void test7591()
|
|
{
|
|
assert(!(get() == 0));
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void foo8966(cfloat x)
|
|
{
|
|
assert(x.re == 3.0f);
|
|
}
|
|
|
|
__gshared cfloat[] a8966;
|
|
|
|
void test8966()
|
|
{
|
|
a8966 = new cfloat[2];
|
|
a8966[0] = 3.0f + 1.0fi;
|
|
foo8966(a8966[0]);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void formatTest2(cfloat s, double re, double im)
|
|
{
|
|
assert(s.re == re);
|
|
assert(s.im == im);
|
|
}
|
|
|
|
cfloat getcf()
|
|
{
|
|
return 2 + 1i;
|
|
}
|
|
|
|
void test10677()
|
|
{
|
|
formatTest2( getcf(), 2, 1 );
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void test7806()
|
|
{
|
|
for (idouble i = -2i; i <= 2i; i += .125i)
|
|
for (double r = -2; r <= 2; r += .0625)
|
|
{
|
|
cdouble c = r + i;
|
|
printf("%g %gi\n", c.re, c.im);
|
|
}
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
void test7976() {
|
|
creal[] a = new creal[2];
|
|
auto b = a[0] = a[1];
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
cfloat foo15f(ifloat re, float im)
|
|
{
|
|
return re + im;
|
|
}
|
|
|
|
cfloat bar15f(float re, ifloat im)
|
|
{
|
|
return re + im;
|
|
}
|
|
|
|
cdouble foo15(idouble re, double im)
|
|
{
|
|
return re + im;
|
|
}
|
|
|
|
cdouble bar15(double re, idouble im)
|
|
{
|
|
return re + im;
|
|
}
|
|
|
|
creal foo15r(ireal re, real im)
|
|
{
|
|
return re + im;
|
|
}
|
|
|
|
creal bar15r(real re, ireal im)
|
|
{
|
|
return re + im;
|
|
}
|
|
|
|
void test15()
|
|
{
|
|
assert(foo15f(1.0fi, 2.0f) == 2.0f + 1.0fi);
|
|
assert(bar15f(1.0f, 2.0fi) == 1.0f + 2.0fi);
|
|
|
|
assert(foo15(1.0i, 2.0) == 2.0 + 1.0i);
|
|
assert(bar15(1.0, 2.0i) == 1.0 + 2.0i);
|
|
|
|
assert(foo15r(1.0Li, 2.0L) == 2.0L + 1.0Li);
|
|
assert(bar15r(1.0L, 2.0Li) == 1.0L + 2.0Li);
|
|
}
|
|
|
|
/***************************************/
|
|
// https://issues.dlang.org/show_bug.cgi?id=17087
|
|
|
|
cfloat toComplex(int x) { return cast(cfloat)x; }
|
|
|
|
void test17087()
|
|
{
|
|
assert (toComplex(1) == 1.0);
|
|
}
|
|
|
|
/***************************************/
|
|
// https://issues.dlang.org/show_bug.cgi?id=17677
|
|
|
|
void test17677()
|
|
{
|
|
cfloat v2 = 0.0f + 0.0fi;
|
|
ulong v1 = 1;
|
|
auto z = v2 + v1;
|
|
assert(z == 1.0f);
|
|
}
|
|
|
|
/***************************************/
|
|
|
|
int main(char[][] args)
|
|
{
|
|
|
|
test1();
|
|
test2();
|
|
test3();
|
|
test4();
|
|
test5();
|
|
test6();
|
|
test7();
|
|
test8();
|
|
test9();
|
|
test10();
|
|
test11();
|
|
test12();
|
|
test13();
|
|
test14();
|
|
test7581();
|
|
test7594();
|
|
test7593();
|
|
test7591();
|
|
test8966();
|
|
test10677();
|
|
test7806();
|
|
test7976();
|
|
test15();
|
|
test17087();
|
|
test17677();
|
|
|
|
printf("Success!\n");
|
|
return 0;
|
|
}
|
|
|