DiaConstraint

DiaConstraint — Constraints used by the DiaSolver.

Synopsis




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

Object Hierarchy


  GObject
   +----DiaConstraint

Signal Prototypes


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

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 *constraint,
                                             DiaVariable *var,
                                             gdouble c);

Add a var * c pair to the constraint.

constraint = constraint + var * c.

constraint :
var :
c :

dia_constraint_add_expression ()

void        dia_constraint_add_expression   (DiaConstraint *constraint,
                                             DiaExpression *expr);

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

constraint :
expr :

dia_constraint_times ()

void        dia_constraint_times            (DiaConstraint *constraint,
                                             gdouble c);

Multiply all constants in the constraint with c.

constraint = (constraint) * c.

constraint :
c :

dia_constraint_has_variables ()

gboolean    dia_constraint_has_variables    (DiaConstraint *constraint);

Determine if constraint has any variables in its equation.

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

dia_constraint_optimize ()

void        dia_constraint_optimize         (DiaConstraint *constraint);

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.

constraint :

dia_constraint_solve ()

gdouble     dia_constraint_solve            (DiaConstraint *constraint,
                                             DiaVariable *var);

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

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

dia_constraint_freeze ()

void        dia_constraint_freeze           (DiaConstraint *constraint);

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.

constraint :

dia_constraint_thaw ()

void        dia_constraint_thaw             (DiaConstraint *constraint);

Inverse function of dia_constraint_freeze().

constraint :

DiaConstraintFunc ()

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

constraint :
variable :
constant :
user_data :

dia_constraint_foreach ()

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

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

constraint :
func :
user_data :

Signals

The "need-resolve" signal

void        user_function                  (DiaConstraint *diaconstraint,
                                            DiaVariable *arg1,
                                            gpointer user_data);

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