TEST_F(ExpressionTests, EqualityTest) {
// First tree operator_expr(-) -> (tup_expr(A.a), const_expr(2))
std::tuple<oid_t, oid_t, oid_t> bound_oid1(1, 1, 1);
auto left1 = new expression::TupleValueExpression("a", "A");
left1->SetBoundOid(bound_oid1);
auto right1 = new expression::ConstantValueExpression(
type::ValueFactory::GetIntegerValue(2));
std::unique_ptr<expression::OperatorExpression> root1(
new expression::OperatorExpression(
ExpressionType::OPERATOR_MINUS, type::TypeId::INVALID, left1, right1));
// Second tree operator_expr(-) -> (tup_expr(A.b), const_expr(2))
std::tuple<oid_t, oid_t, oid_t> bound_oid2(1, 1, 0);
auto left2 = new expression::TupleValueExpression("b", "A");
left2->SetBoundOid(bound_oid2);
auto right2 = new expression::ConstantValueExpression(
type::ValueFactory::GetIntegerValue(2));
std::unique_ptr<expression::OperatorExpression> root2(
new expression::OperatorExpression(
ExpressionType::OPERATOR_MINUS, type::TypeId::INVALID, left2, right2));
EXPECT_FALSE(root1->Equals(root2.get()));
// Third tree operator_expr(-) -> (tup_expr(a.a), const_expr(2))
auto left3 = new expression::TupleValueExpression("a", "a");
left3->SetBoundOid(bound_oid1);
auto right3 = new expression::ConstantValueExpression(
type::ValueFactory::GetIntegerValue(2));
std::unique_ptr<expression::OperatorExpression> root3(
new expression::OperatorExpression(
ExpressionType::OPERATOR_MINUS, type::TypeId::INVALID, left3, right3));
EXPECT_TRUE(root1->Equals(root3.get()));
}
TEST_F(ExpressionTests, HashTest) {
// First tree operator_expr(-) -> (tup_expr(A.a), const_expr(2))
auto left1 = new expression::TupleValueExpression("a", "A");
auto oids1 = std::make_tuple<oid_t, oid_t, oid_t>(0,0,0);
left1->SetBoundOid(oids1);
auto right1 = new expression::ConstantValueExpression(
type::ValueFactory::GetIntegerValue(2));
std::unique_ptr<expression::OperatorExpression> root1(
new expression::OperatorExpression(
ExpressionType::OPERATOR_MINUS, type::TypeId::INVALID, left1, right1));
LOG_INFO("Hash(tree1)=%ld", root1->Hash());
// Second tree operator_expr(-) -> (tup_expr(A.b), const_expr(2))
auto left2 = new expression::TupleValueExpression("b", "A");
auto oids2 = std::make_tuple<oid_t, oid_t, oid_t>(0,0,1);
left2->SetBoundOid(oids2);
auto right2 = new expression::ConstantValueExpression(
type::ValueFactory::GetIntegerValue(2));
std::unique_ptr<expression::OperatorExpression> root2(
new expression::OperatorExpression(
ExpressionType::OPERATOR_MINUS, type::TypeId::INVALID, left2, right2));
LOG_INFO("Hash(tree2)=%ld", root2->Hash());
EXPECT_NE(root1->Hash(), root2->Hash());
// Third tree operator_expr(-) -> (tup_expr(A.a), const_expr(2))
auto left3 = new expression::TupleValueExpression("a", "A");
auto oids3 = oids1;
left3->SetBoundOid(oids3);
auto right3 = new expression::ConstantValueExpression(
type::ValueFactory::GetIntegerValue(2));
std::unique_ptr<expression::OperatorExpression> root3(
new expression::OperatorExpression(
ExpressionType::OPERATOR_MINUS, type::TypeId::INVALID, left3, right3));
LOG_INFO("Hash(tree3)=%ld", root3->Hash());
EXPECT_EQ(root1->Hash(), root3->Hash());
}
static int
exp_find_roots(double a1, double a2, double a3, double *ex1, double *ex2, double *ex3)
{
double x, t;
double p, q;
q = (a1*a1-3.0*a2) / 9.0;
p = (2.0*a1*a1*a1-9.0*a1*a2+27.0*a3) / 54.0;
t = q*q*q - p*p;
if (t >= 0.0) {
t = acos(p /(q * sqrt(q)));
x = -2.0*sqrt(q)*cos(t / 3.0) - a1/3.0;
} else {
if (p > 0.0) {
t = pow(sqrt(-t)+p, 1.0 / 3.0);
x = -(t + q / t) - a1/3.0;
} else if (p == 0.0) {
x = -a1/3.0;
} else {
t = pow(sqrt(-t)-p, 1.0 / 3.0);
x = (t + q / t) - a1/3.0;
}
}
{
double ex1;
int i = 0;
ex1 = x;
for (t = root3(a1, a2, a3, x); ABS(t-x) > 5.0e-4;
t = root3(a1, a2, a3, x))
if (++i == 32) {
x = ex1;
break;
} else
x = t;
}
/***
x = a1;
for (t = root3(a1, a2, a3, x); ABS(t-x) > epsi2;
t = root3(a1, a2, a3, x)) {
x = t;
i++;
if (i > 1000) {
x = 0.5 * (x + root3(a1, a2, a3, x));
j++;
if (j == 3)
break;
i = 0;
}
}
***/
*ex1 = x;
div3(a1, a2, a3, x, &a1, &a2);
t = a1 * a1 - 4.0 * a2;
if (t < 0) {
ifImg = 1;
printf("***** Two Imaginary Roots.\n");
*ex3 = 0.5 * sqrt(-t);
*ex2 = -0.5 * a1;
} else {
ifImg = 0;
t *= 1.0e-16;
t = sqrt(t)*1.0e8;
if (a1 >= 0.0)
*ex2 = t = -0.5 * (a1 + t);
else
*ex2 = t = -0.5 * (a1 - t);
*ex3 = a2 / t;
/*
*ex2 = 0.5 * (-a1 + t);
*ex3 = 0.5 * (-a1 - t);
*/
}
return(1);
}
static int
find_roots(double a1, double a2, double a3, double *x1, double *x2, double *x3)
{
double x, t;
double p, q;
q = (a1*a1-3.0*a2) / 9.0;
p = (2.0*a1*a1*a1-9.0*a1*a2+27.0*a3) / 54.0;
t = q*q*q - p*p;
if (t >= 0.0) {
t = acos(p /(q * sqrt(q)));
x = -2.0*sqrt(q)*cos(t / 3.0) - a1/3.0;
} else {
if (p > 0.0) {
t = pow(sqrt(-t)+p, 1.0 / 3.0);
x = -(t + q / t) - a1/3.0;
} else if (p == 0.0) {
x = -a1/3.0;
} else {
t = pow(sqrt(-t)-p, 1.0 / 3.0);
x = (t + q / t) - a1/3.0;
}
}
{
double x_backup = x;
int i = 0;
for (t = root3(a1, a2, a3, x); ABS(t-x) > 5.0e-4;
t = root3(a1, a2, a3, x))
if (++i == 32) {
x = x_backup;
break;
} else
x = t;
}
/*
x = a1;
i = 0;
j = 0;
for (t = root3(a1, a2, a3, x); ABS(t-x) > epsi;
t = root3(a1, a2, a3, x)) {
x = t;
i++;
if (i > 1000) {
x = 0.5 * (x + root3(a1, a2, a3, x));
j++;
if (j == 3)
break;
i = 0;
}
}
*/
*x1 = x;
div3(a1, a2, a3, x, &a1, &a2);
t = a1 * a1 - 4.0 * a2;
if (t < 0) {
printf("***** Two Imaginary Roots in Characteristic Admittance.\n");
controlled_exit(EXIT_FAILURE);
}
t *= 1.0e-18;
t = sqrt(t) * 1.0e9;
if (a1 >= 0.0)
*x2 = t = -0.5 * (a1 + t);
else
*x2 = t = -0.5 * (a1 - t);
*x3 = a2 / t;
/*
*x2 = 0.5 * (-a1 + t);
*x3 = 0.5 * (-a1 - t);
*/
return(1);
}
