int parse_factor(CALC_ELEMENT ** e)
{
PARSE_SYMBOL s = get_symbol();
switch (s) {
case PARSE_NUMBER:
*e = create_number(get_current_number());
accept(s);
return 0;
break;
case PARSE_X:
*e = create_x();
accept(s);
return 0;
break;
case PARSE_LOG:
return parse_log(e);
break;
case PARSE_LPAREN:
return parse_paren_expr(e);
break;
default:
parser_error("\'number\', \'x\', \'log\' or \'(\'");
return -1;
}
}
void test_calc_bad(void)
{
CALC_ELEMENT *t1, *t2;
/* division by zero, simple */
t1 = create_number(9.0);
t2 = create_number(0.0);
t1 = create_bin_op('/', t1, t2);
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DIV_BY_ZERO,
STATUS_CALC_DIV_BY_ZERO);
free_calc_element(t1);
/* division by zero, complex */
t1 = create_bin_op('/', create_number(4.0),
create_bin_op('-', create_number(2.0),
create_number(2.0)));
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DIV_BY_ZERO,
STATUS_CALC_DIV_BY_ZERO);
free_calc_element(t1);
/* log zero */
t1 = create_log(create_number(0.0));
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DOMAIN, STATUS_CALC_DOMAIN);
free_calc_element(t1);
/* log less than zero */
t1 = create_log(create_number(-3.0));
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DOMAIN, STATUS_CALC_DOMAIN);
free_calc_element(t1);
/* log zero, complex */
t1 = create_log(create_bin_op
('*', create_number(0.0), create_number(28.0)));
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DOMAIN, STATUS_CALC_DOMAIN);
free_calc_element(t1);
/* x in the expression, simple */
t1 = create_x();
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_X_PRESENT, STATUS_X_PRESENT);
free_calc_element(t1);
/* x in the expression, complex */
t1 = create_bin_op('-', create_x(), create_number(17));
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_X_PRESENT, STATUS_X_PRESENT);
free_calc_element(t1);
}
void Logo::create_all() {
create_z(Point2f(m_upper_left.x - 0.99f * m_height, m_upper_left.y + 0.25f * m_height), 0.5f * m_height);
create_e(Point2f(m_upper_left.x - 0.55f * m_height, m_upper_left.y + 0.25f * m_height), 0.5f * m_height);
create_n(Point2f(m_upper_left.x - 0.11f * m_height, m_upper_left.y + 0.25f * m_height), 0.5f * m_height);
create_i(Point2f(m_upper_left.x + 0.33f * m_height, m_upper_left.y + 0.25f * m_height), 0.5f * m_height);
create_p(Point2f(m_upper_left.x + 0.77f * m_height, m_upper_left.y + 0.25f * m_height), 0.5f * m_height);
create_e(Point2f(m_upper_left.x + 1.21f * m_height, m_upper_left.y + 0.25f * m_height), 0.5f * m_height);
create_x(Point2f(m_upper_left.x + 1.65f * m_height, m_upper_left.y + 0.25f * m_height), 0.5f * m_height);
create_logo(m_upper_left, m_height);
}
void test_x_cf(void)
{
CALC_ELEMENT *t1 = create_x();
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_X);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(t1->value, 1.0);
CU_ASSERT_PTR_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
}
void test_bad_axb(void)
{
CALC_ELEMENT *t1, *t2, *t3;
double a, b;
/* log */
t2 = create_number(6.0);
t1 = create_log(t2);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1);
free_calc_element(t1);
/* bin op different from + */
t2 = create_number(-9.0);
t3 = create_x();
t1 = create_bin_op('*', t2, t3);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1);
free_calc_element(t1);
/* two numbers */
t2 = create_number(2.0);
t3 = create_number(4.2);
t1 = create_bin_op('+', t2, t3);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1);
free_calc_element(t1);
/* two xs */
t2 = create_x();
t3 = create_x();
t1 = create_bin_op('*', t2, t3);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1);
free_calc_element(t1);
/* something wonky, like 4 * 3 + 2 */
t2 = create_number(4);
t3 = create_number(3);
t2 = create_bin_op('*', t2, t3);
t3 = create_number(2);
t1 = create_bin_op('+', t2, t3);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1);
free_calc_element(t1);
}
void test_log_cf(void)
{
CALC_ELEMENT *t1 = create_number(1.0);
t1 = create_log(t1);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_LOG);
CU_ASSERT_EQUAL(t1->status, 0);
CU_ASSERT_EQUAL(t1->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
t1 = create_x();
t1 = create_log(t1);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_LOG);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT | STATUS_X_IN_LOG);
CU_ASSERT_EQUAL(t1->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
}
void test_binop_cf(void)
{
/* + */
CALC_ELEMENT *e1 = create_number(3.0), *e2 = create_number(-4.0);
CALC_ELEMENT *expr = create_bin_op('+', e1, e2);
CU_ASSERT_PTR_NOT_NULL(expr);
CU_ASSERT_EQUAL(expr->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(expr->bin_op, '+');
CU_ASSERT_EQUAL(expr->status, 0);
CU_ASSERT_EQUAL(expr->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(expr->left);
CU_ASSERT_PTR_NOT_NULL(expr->right);
free_calc_element(expr);
/* - */
e1 = create_number(-7.0);
e2 = create_number(9.0);
expr = create_bin_op('-', e1, e2);
CU_ASSERT_PTR_NOT_NULL(expr);
CU_ASSERT_EQUAL(expr->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(expr->bin_op, '+');
CU_ASSERT_EQUAL(expr->status, 0);
CU_ASSERT_EQUAL(expr->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(expr->left);
CU_ASSERT_PTR_NOT_NULL(expr->right);
CU_ASSERT_EQUAL(expr->right->value, -9.0);
free_calc_element(expr);
/* * */
e1 = create_number(3.0);
e2 = create_number(11.5);
expr = create_bin_op('*', e1, e2);
CU_ASSERT_PTR_NOT_NULL(expr);
CU_ASSERT_EQUAL(expr->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(expr->bin_op, '*');
CU_ASSERT_EQUAL(expr->status, 0);
CU_ASSERT_EQUAL(expr->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(expr->left);
CU_ASSERT_PTR_NOT_NULL(expr->right);
free_calc_element(expr);
/* /, only numbers */
e1 = create_number(-7.0);
e2 = create_number(5.0);
expr = create_bin_op('/', e1, e2);
CU_ASSERT_PTR_NOT_NULL(expr);
CU_ASSERT_EQUAL(expr->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(expr->bin_op, '/');
CU_ASSERT_EQUAL(expr->status, 0);
CU_ASSERT_EQUAL(expr->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(expr->left);
CU_ASSERT_PTR_NOT_NULL(expr->right);
free_calc_element(expr);
/* /, with an x */
e1 = create_x();
e2 = create_number(2.0);
expr = create_bin_op('/', e1, e2);
CU_ASSERT_PTR_NOT_NULL(expr);
CU_ASSERT_EQUAL(expr->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(expr->bin_op, '/');
CU_ASSERT_EQUAL(expr->status, STATUS_X_PRESENT | STATUS_X_IN_DIV);
CU_ASSERT_EQUAL(expr->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(expr->left);
CU_ASSERT_PTR_NOT_NULL(expr->right);
free_calc_element(expr);
}
void test_canon_x(void)
{
CALC_ELEMENT *t1;
double a, b;
/* addition x + a * x */
t1 = create_bin_op('+', create_x(),
create_bin_op('*', create_number(2.5), create_x()));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_X);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(t1->value, 3.5);
free_calc_element(t1);
/* addition a * x + b */
t1 = create_bin_op('+',
create_bin_op('*', create_number(1.25), create_x()),
create_number(14));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 1.25);
CU_ASSERT_EQUAL(b, 14);
free_calc_element(t1);
/* addition a * x + b + c */
t1 = create_bin_op('+',
create_bin_op('+',
create_bin_op('*', create_number(0.75),
create_x()),
create_number(6)),
create_number(-3.5));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 0.75);
CU_ASSERT_EQUAL(b, 2.5);
free_calc_element(t1);
/* addition (a1 * x + b1) + (a2 * x + b2) */
t1 = create_bin_op('+', create_ax_b(9.0, -1.25), create_ax_b(2.0, 6.5));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 11.0);
CU_ASSERT_EQUAL(b, 5.25);
free_calc_element(t1);
/* multiplication a * x */
t1 = create_bin_op('*', create_x(), create_number(-9.0));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_X);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, -9.0);
CU_ASSERT_EQUAL(b, 0);
free_calc_element(t1);
/* multiplication x * a */
t1 = create_bin_op('*', create_number(7.5), create_x());
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_X);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 7.5);
CU_ASSERT_EQUAL(b, 0);
free_calc_element(t1);
/* multiplication c * (a * x + b) */
t1 = create_bin_op('*', create_number(19), create_ax_b(4, -0.5));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 76);
CU_ASSERT_EQUAL(b, -9.5);
free_calc_element(t1);
/* multiplication (a * x + b) * c */
t1 = create_bin_op('*', create_ax_b(-6, 4.5), create_number(0.5));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, -3.0);
CU_ASSERT_EQUAL(b, 2.25);
free_calc_element(t1);
/* multiplication x * x */
t1 = create_bin_op('*', create_x(), create_x());
CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_NON_LINEAR | STATUS_X_PRESENT);
free_calc_element(t1);
/* multiplication x * (a * x + b) */
t1 = create_bin_op('*', create_x(), create_x());
CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_NON_LINEAR | STATUS_X_PRESENT);
free_calc_element(t1);
/* multiplication (2*x - (2*x - 3)) * (3x - 4) - false square, actually linear */
t1 = create_bin_op('*', create_bin_op('-', create_ax_b(2.0, 0.0),
create_ax_b(2, -3)),
create_ax_b(3.0, -4.0));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 9.0);
CU_ASSERT_EQUAL(b, -12.0);
free_calc_element(t1);
/* division x / a */
t1 = create_bin_op('/', create_x(), create_number(2.0));
CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_IN_DIV | STATUS_X_PRESENT);
free_calc_element(t1);
/* log (ax + b) */
t1 = create_log(create_ax_b(9.0, -3.0));
CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_LOG);
CU_ASSERT_EQUAL(t1->status, STATUS_X_IN_LOG | STATUS_X_PRESENT);
free_calc_element(t1);
}
