starwing / amoeba Goto Github PK

am_Solver * solver = am_newsolver(NULL, NULL);

am_Variable * va = am_newvariable(solver);
am_Variable * vb = am_newvariable(solver);
am_Variable * vc = am_newvariable(solver);
am_Variable * vd = am_newvariable(solver);

int ret = 0;

am_addedit(va, AM_STRONG);

// vb == va
{
	ret = 0;
	am_Constraint * c = am_newconstraint(solver, AM_REQUIRED);
	ret |= am_addterm(c, vb, 1.0);
	ret |= am_setrelation(c, AM_EQUAL);
	ret |= am_addterm(c, va, 1.0);
	ret |= am_add(c);
	assert(ret == AM_OK);
}

// vb == vc
{
	ret = 0;
	am_Constraint * c = am_newconstraint(solver, AM_REQUIRED);
	ret |= am_addterm(c, vb, 1.0);
	ret |= am_setrelation(c, AM_EQUAL);
	ret |= am_addterm(c, vc, 1.0);
	ret |= am_add(c);
	assert(ret == AM_OK);
}

// vc == vd
{
	ret = 0;
	am_Constraint * c = am_newconstraint(solver, AM_REQUIRED);
	ret |= am_addterm(c, vc, 1.0);
	ret |= am_setrelation(c, AM_EQUAL);
	ret |= am_addterm(c, vd, 1.0);
	ret |= am_add(c);
	assert(ret == AM_OK);
}

// vd == va
{
	ret = 0;
	am_Constraint * c = am_newconstraint(solver, AM_REQUIRED);
	ret |= am_addterm(c, vd, 1.0);
	ret |= am_setrelation(c, AM_EQUAL);
	ret |= am_addterm(c, va, 1.0);
	ret |= am_add(c);
	assert(ret == AM_OK); // asserts here
}

from kiwisolver import Solver, Variable

s = Solver()

a = Variable('a')
b = Variable('b')
c = Variable('c')
d = Variable('d')

s.addEditVariable(a, 'strong')

s.addConstraint(a == b)
s.addConstraint(b == c)
s.addConstraint(c == d)
s.addConstraint(a == d)

s.suggestValue(a, 2)
s.updateVariables()

print(a.value()) # all variables are 2
print(b.value())
print(c.value())
print(d.value())

        // Ycur = Yprev_row + 10
        pC = am_newconstraint(pSolver, AM_REQUIRED);
        am_addterm(pC, arrY[nCurrentRowFirstPointIndex + nPoint], 1.0);
        am_setrelation(pC, AM_EQUAL);
        am_addterm(pC, arrY[nCurrentRowFirstPointIndex - 1], 1.0);
        am_addconstant(pC, 10.0);
        nResult = am_add(pC);
        assert(nResult == AM_OK);

#include <stdio.h>
#include <stdarg.h>

#define AM_IMPLEMENTATION
#include "amoeba.h"
#define END 0

am_Constraint* new_constraint(am_Solver* in_solver, double in_strength, am_Variable* in_term1,
	double in_factor1, int in_relation, double in_constant, ...) {
	int result;
	va_list argp;
	am_Constraint* c;
	assert(in_solver && in_term1);
	c = am_newconstraint(in_solver, in_strength ? in_strength : AM_REQUIRED);
	if(!c) return 0;
	am_addterm(c, in_term1, in_factor1);
	am_setrelation(c, in_relation);
	if(in_constant) am_addconstant(c, in_constant);
	va_start(argp, in_constant);
	while(1) {
		am_Variable* va_term = va_arg(argp, am_Variable*);
		double va_factor = va_arg(argp, double);
		if(va_term == 0) break;
		am_addterm(c, va_term, va_factor);
	}
	va_end(argp);
	result = am_add(c);
	assert(result == AM_OK);
	return c;
}

int main(int argc, const char * argv[]) {

	double delta = 0;
	double pos;
	am_Solver* solver = am_newsolver(0, NULL);
	am_Variable* splitter_l = am_newvariable(solver);
	am_Variable* splitter_w = am_newvariable(solver);
	am_Variable* splitter_r = am_newvariable(solver);
	am_Variable* left_child_l = am_newvariable(solver);
	am_Variable* left_child_w = am_newvariable(solver);
	am_Variable* left_child_r = am_newvariable(solver);
	am_Variable* splitter_bar_l = am_newvariable(solver);
	am_Variable* splitter_bar_w = am_newvariable(solver);
	am_Variable* splitter_bar_r = am_newvariable(solver);
	am_Variable* right_child_l = am_newvariable(solver);
	am_Variable* right_child_w = am_newvariable(solver);
	am_Variable* right_child_r = am_newvariable(solver);
	/* splitter_r = splitter_l + splitter_w */
	/* left_child_r = left_child_l + left_child_w */
	/* splitter_bar_r = splitter_bar_l + splitter_bar_w */
	/* right_child_r = right_child_l + right_child_w */
	am_Constraint* c1 = new_constraint(solver, AM_REQUIRED, splitter_r, 1.0, AM_EQUAL, 0.0,
		splitter_l, 1.0, splitter_w, 1.0, END);
	am_Constraint* c2 = new_constraint(solver, AM_REQUIRED, left_child_r, 1.0, AM_EQUAL, 0.0,
		left_child_l, 1.0, left_child_w, 1.0, END);
	am_Constraint* c3 = new_constraint(solver, AM_REQUIRED, splitter_bar_r, 1.0, AM_EQUAL, 0.0,
		splitter_bar_l, 1.0, splitter_bar_w, 1.0, END);
	am_Constraint* c4 = new_constraint(solver, AM_REQUIRED, right_child_r, 1.0, AM_EQUAL, 0.0,
		right_child_l, 1.0, right_child_w, 1.0, END);
	/* splitter_bar_w = 6 */
	/* splitter_bar_l >= splitter_l + delta */
	/* splitter_bar_r <= splitter_r - delta */
	/* left_child_r = splitter_bar_l */
	/* right_child_l = splitter_bar_r */
	am_Constraint* c5 = new_constraint(solver, AM_REQUIRED, splitter_bar_w, 1.0, AM_EQUAL, 6.0, END);
	am_Constraint* c6 = new_constraint(solver, AM_REQUIRED, splitter_bar_l, 1.0, AM_GREATEQUAL,
		delta, splitter_l, 1.0, END);
	am_Constraint* c7 = new_constraint(solver, AM_REQUIRED, splitter_bar_r, 1.0, AM_LESSEQUAL,
		-delta, splitter_r, 1.0, END);
	am_Constraint* c8 = new_constraint(solver, AM_REQUIRED, left_child_r, 1.0, AM_EQUAL, 0.0,
		splitter_bar_l, 1.0, END);
	am_Constraint* c9 = new_constraint(solver, AM_REQUIRED, right_child_l, 1.0, AM_EQUAL, 0.0,
		splitter_bar_r, 1.0, END);
#if 0
	/* This should be valid but fails the (enter.id != 0) assertion in am_dual_optimize() */
	int strength1 = AM_REQUIRED;
	int strength2 = AM_REQUIRED;
	int width = 76;
#else
	/* This mostly works, but still insists on forcing left_child_l = 0 which it should not */
	int strength1 = AM_STRONG;
	int strength2 = AM_WEAK;
	int width = 76;
#endif
	/* right_child_r >= splitter_r + 1 */
	/* left_child_w = 256 */
	am_Constraint* c10 = new_constraint(solver, strength1, right_child_r, 1.0, AM_GREATEQUAL, 1.0,
		splitter_r, 1.0, END);
	am_Constraint* c11 = new_constraint(solver, strength2, left_child_w, 1.0, AM_EQUAL, 256.0, END);
	/* splitter_l = 0 */
	/* splitter_r = 76 */
	am_Constraint* c12 = new_constraint(solver, AM_REQUIRED, splitter_l, 1.0, AM_EQUAL, 0.0, END);
	am_Constraint* c13 = new_constraint(solver, AM_REQUIRED, splitter_r, 1.0, AM_EQUAL, width, END);

	for(pos = -10; pos < 86; pos++) {
		am_suggest(splitter_bar_l, pos);
		printf("pos: %4g | ", pos);
		printf("splitter_l l=%2g, w=%2g, r=%2g | ", am_value(splitter_l),
			am_value(splitter_w), am_value(splitter_r));
		printf("left_child_l l=%2g, w=%2g, r=%2g | ", am_value(left_child_l),
			am_value(left_child_w), am_value(left_child_r));
		printf("splitter_bar_l l=%2g, w=%2g, r=%2g | ", am_value(splitter_bar_l),
			am_value(splitter_bar_w), am_value(splitter_bar_r));
		printf("right_child_l l=%2g, w=%2g, r=%2g | ", am_value(right_child_l),
			am_value(right_child_w), am_value(right_child_r));
		printf("\n");
	}

	(void) c1; (void) c2; (void) c3; (void) c4; (void) c5; (void) c6; (void) c7; (void) c8;
	(void) c9; (void) c10; (void) c11; (void) c12; (void) c13;
	return 0;
}