DiaConstraint

DiaConstraint — Constraints used by the DiaSolver.

Synopsis




#define     DIA_CONSTRAINT                  (obj)
            DiaConstraint;
DiaConstraint* dia_constraint_new           (void);
void        dia_constraint_add              (DiaConstraint *const raint,
                                             DiaVariable *var,
                                             gdouble c);
void        dia_constraint_add_expression   (DiaConstraint *const raint,
                                             DiaExpression *expr);
void        dia_constraint_times            (DiaConstraint *const raint,
                                             gdouble c);
gboolean    dia_constraint_has_variables    (DiaConstraint *const raint);
void        dia_constraint_optimize         (DiaConstraint *const raint);
gdouble     dia_constraint_solve            (DiaConstraint *const raint,
                                             DiaVariable *var);
void        dia_constraint_freeze           (DiaConstraint *const raint);
void        dia_constraint_thaw             (DiaConstraint *const raint);
void        (*DiaConstraintFunc)            (DiaConstraint *const raint,
                                             DiaVariable *variable,
                                             gdouble constant,
                                             gpointer user_data);
void        dia_constraint_foreach          (DiaConstraint *const raint,
                                             DiaConstraintFunc func,
                                             gpointer user_data);

Object Hierarchy


  GObject
   +----DiaConstraint

Signals


"need-resolve"
            void        user_function      (DiaConstraint *diaconstraint,
                                            DiaVariable   *arg1,
                                            gpointer       user_data)          : Run last

Description

A constraint contains a linear expression (DiaExpression). A constraint can be added to a constraint solver (DiaSolver) in order to keep it true. Once a constraint is added to a solver, it can no longer be changed.

If a variable (DiaVariable) is changed, the constraint is notified and it will on his turn notify the solver that it should be resolved again. The solver will resolve the constraint when it is asked to.

Details

DIA_CONSTRAINT()

#define DIA_CONSTRAINT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), DIA_TYPE_CONSTRAINT, DiaConstraint))

obj :

DiaConstraint

typedef struct _DiaConstraint DiaConstraint;


dia_constraint_new ()

DiaConstraint* dia_constraint_new           (void);

Create an empty constraint.

Returns : A new constraint object.

dia_constraint_add ()

void        dia_constraint_add              (DiaConstraint *const raint,
                                             DiaVariable *var,
                                             gdouble c);

Add a var * c pair to the constraint.

constraint = constraint + var * c.

raint :
var :
c :

dia_constraint_add_expression ()

void        dia_constraint_add_expression   (DiaConstraint *const raint,
                                             DiaExpression *expr);

Add a DiaExpression to constraint. A DiaExpression containts one or more variable-constant pairs.

raint :
expr :

dia_constraint_times ()

void        dia_constraint_times            (DiaConstraint *const raint,
                                             gdouble c);

Multiply all constants in the constraint with c.

constraint = (constraint) * c.

raint :
c :

dia_constraint_has_variables ()

gboolean    dia_constraint_has_variables    (DiaConstraint *const raint);

Determine if constraint has any variables in its equation.

raint :
Returns : TRUE if the constraint contains variables, FALSE otherwise.

dia_constraint_optimize ()

void        dia_constraint_optimize         (DiaConstraint *const raint);

Optimeze the constraint. This is done by merging all variable-constant pairs whose variable is the same and removing all pairs with a constant of 0.0.

raint :

dia_constraint_solve ()

gdouble     dia_constraint_solve            (DiaConstraint *const raint,
                                             DiaVariable *var);

Solve a constraint with var being the variable that should be changed.

raint :
var :
Returns : G_MAXDOUBLE on error, otherwise the value that var should be assigned too.

dia_constraint_freeze ()

void        dia_constraint_freeze           (DiaConstraint *const raint);

Make the constraint immutable. As a result no more variable-constant pairs can be added. This function is typically used by the DiaSolver to make sure a constraint does not change after it has been added to the solver.

raint :

dia_constraint_thaw ()

void        dia_constraint_thaw             (DiaConstraint *const raint);

Inverse function of dia_constraint_freeze().

raint :

DiaConstraintFunc ()

void        (*DiaConstraintFunc)            (DiaConstraint *const raint,
                                             DiaVariable *variable,
                                             gdouble constant,
                                             gpointer user_data);

raint :
variable :
constant :
user_data :

dia_constraint_foreach ()

void        dia_constraint_foreach          (DiaConstraint *const raint,
                                             DiaConstraintFunc func,
                                             gpointer user_data);

Call func for every variable-constant pair in the constraint.

raint :
func :
user_data :

Signal Details

The "need-resolve" signal

void        user_function                  (DiaConstraint *diaconstraint,
                                            DiaVariable   *arg1,
                                            gpointer       user_data)          : Run last

Signal used to tell the DiaSolver that the constraint needs to be resolved.

diaconstraint : the object which received the signal.
arg1 :
user_data : user data set when the signal handler was connected.

See Also

DiaSolver, DiaExpression, DiaVariable