static ALLEGRO_COLOR reference_implementation(
ALLEGRO_COLOR src_col, ALLEGRO_COLOR dst_col,
ALLEGRO_COLOR blend_col, int src_format, int dst_format,
int src_mode, int dst_mode, int src_alpha, int dst_alpha,
int operation)
{
float sr, sg, sb, sa;
float br, bg, bb, ba;
float dr, dg, db, da;
float r, g, b, a;
float src, dst, asrc, adst;
al_unmap_rgba_f(src_col, &sr, &sg, &sb, &sa);
al_unmap_rgba_f(blend_col, &br, &bg, &bb, &ba);
al_unmap_rgba_f(dst_col, &dr, &dg, &db, &da);
/* Do we even have source alpha? */
if (operation == 0) {
if (!has_alpha(src_format)) {
sa = 1;
}
}
r = sr * br;
g = sg * bg;
b = sb * bb;
a = sa * ba;
src = get_factor(src_mode, a);
dst = get_factor(dst_mode, a);
asrc = get_factor(src_alpha, a);
adst = get_factor(dst_alpha, a);
r = r * src + dr * dst;
g = g * src + dg * dst;
b = b * src + db * dst;
a = a * asrc + da * adst;
r = CLAMP(r);
g = CLAMP(g);
b = CLAMP(b);
a = CLAMP(a);
/* Do we even have destination alpha? */
if (!has_alpha(dst_format)) {
a = 1;
}
return al_map_rgba_f(r, g, b, a);
}
Ref<InputEvent> InputEventMagnifyGesture::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const {
Ref<InputEventMagnifyGesture> ev;
ev.instance();
ev->set_device(get_device());
ev->set_modifiers_from_event(this);
ev->set_position(p_xform.xform(get_position() + p_local_ofs));
ev->set_factor(get_factor());
return ev;
}
void show_board(Board* board) {
reset_screen();
int size = get_size(board);
int factor = get_factor(board);
for(int i = 0; i < size; i++) {
display_space(get_space(board, i), i);
if (is_row_transition(i, factor, size)) {
display_row_transition(factor);
}
if (is_cell_transition(i, factor)) {
write_out(cell_transition_message);
}
}
write_out(end_board_message);
}
static node_t *get_factortail(token_stack_t *stack, node_t *left_expr, GError **err)
{
const token_t *token;
node_t *op, *expr;
GError *tmp_err = NULL;
token = token_peak(stack);
/* First check if we really have a factortail here. If not, return the
* factor. */
if (token == NULL) {
g_free(token_pop(stack));
return left_expr;
} else if (!(token->type == TOK_OPERATOR && is_mult_op(token->val.op)))
return left_expr;
op = g_malloc(sizeof(node_t));
op->left = left_expr;
op->type = NODE_OPERATOR;
switch (token->val.op) {
case '*':
op->val.op = OP_TIMES;
break;
case '/':
op->val.op = OP_DIV;
break;
default:
set_error(err, "Expected '*' or '/'", token);
g_free(op);
return left_expr;
}
g_free(token_pop(stack));
/* Then there should be a factor. */
op->right = get_factor(stack, &tmp_err);
if (tmp_err) {
g_propagate_error(err, tmp_err);
return op;
}
/* and finally another factortail */
expr = get_factortail(stack, op, &tmp_err);
if (tmp_err)
g_propagate_error(err, tmp_err);
return expr;
}
static node_t *get_term(token_stack_t *stack, GError **err)
{
node_t *factor, *expr;
GError *tmp_err = NULL;
factor = get_factor(stack, &tmp_err);
if (tmp_err) {
g_propagate_error(err, tmp_err);
return factor;
}
expr = get_factortail(stack, factor, &tmp_err);
if (tmp_err)
g_propagate_error(err, tmp_err);
return expr;
}
String InputEventMagnifyGesture::as_text() const {
return "InputEventMagnifyGesture : factor=" + rtos(get_factor()) + ", position=(" + String(get_position()) + ")";
}
void
yyfactorpoly(void)
{
int h, i;
save();
X = pop();
POLY = pop();
h = tos;
if (isfloating(POLY))
stop("floating point numbers in polynomial");
polycoeff = stack + tos;
push(POLY);
push(X);
expo = coeff() - 1;
rationalize_coefficients(h);
// for univariate polynomials we could do expo > 1
while (expo > 0) {
if (iszero(polycoeff[0])) {
push_integer(1);
A = pop();
push_integer(0);
B = pop();
} else if (get_factor() == 0) {
if (verbosing)
//!!!////printf("no factor found\n");
break;
}
push(A);
push(X);
multiply();
push(B);
add();
FACTOR = pop();
if (verbosing) {
//////printf("success\nFACTOR=");
print(FACTOR);
//////printf("\n");
}
// factor out negative sign (not req'd because A > 1)
#if 0
if (isnegativeterm(A)) {
push(FACTOR);
negate();
FACTOR = pop();
push(RESULT);
negate_noexpand();
RESULT = pop();
}
#endif
push(RESULT);
push(FACTOR);
multiply_noexpand();
RESULT = pop();
yydivpoly();
while (expo && iszero(polycoeff[expo]))
expo--;
}
// unfactored polynomial
push(zero);
for (i = 0; i <= expo; i++) {
push(polycoeff[i]);
push(X);
push_integer(i);
power();
multiply();
add();
}
POLY = pop();
if (verbosing) {
//////printf("POLY=");
print(POLY);
//////printf("\n");
}
// factor out negative sign
if (expo > 0 && isnegativeterm(polycoeff[expo])) {
push(POLY);
negate();
POLY = pop();
push(RESULT);
negate_noexpand();
RESULT = pop();
}
push(RESULT);
push(POLY);
multiply_noexpand();
RESULT = pop();
if (verbosing) {
//////printf("RESULT=");
print(RESULT);
//////printf("\n");
}
stack[h] = RESULT;
tos = h + 1;
restore();
}
fbreal term_integral(PolynomialTerm T,fbreal a,fbreal b,fbreal c) {
return T.coefficient
*get_factor(T.exponents[0],T.exponents[1],a)
*get_factor(T.exponents[2],T.exponents[3],b)
*get_factor(T.exponents[4],T.exponents[5],c);
}
void test_board_factor() {
Board* board = new_board(3);
assert(get_factor(board) == 3);
destroy_board(board);
}
