On-the-fly Le Chatelier

[JKop]

I have a "system", this system is 5 values:

A
B
C
D
E
Each of these values is dependant upon all others. If you want an analogy,
then take your pick:

A) Electricity: Current is proportional to Voltage, and also to Resistence

B) Gases: Volume is proportional to Pressure, and also to Temperature

So if one value changes, they all change.
Anyway, at then end of the whole design, I want my GUI to be able to just
work with it similar to the following:

cout << somesystem.GetA ();
cout << somesystem.GetB ();
cout << somesystem.GetC ();
cout << somesystem.GetD ();
cout << somesystem.GetE ();
I want to create a class to represent this system. The particular class with
which the GUI will work doesn't need to have any Set functions, so the bare
minimum would be:

class SystemX
{
public:

int GetA() const;
int GetB() const;
int GetC() const;
int GetD() const;
int GetE() const;
};

or maybe even:

class SystemX
{
public:

virtual int GetA() const = 0;
virtual int GetB() const = 0;
virtual int GetC() const = 0;
virtual int GetD() const = 0;
virtual int GetE() const = 0;
};
Now... in actually implementing this system, I *could* use 5 separate
variables and update them all at precisely the moment one of them changes.
Like so:

class SystemX
{
private:

int A;
int B;
int C;
int D;
int E;

public:

int GetA() const
{
return A;
}

int GetB() const
{
return B;
}

int GetC() const
{
return C;
}

void SetA(int in_A)
{
//Super algorithm

A = in_A;

B = A + 4;
C = A / 9;
D = 42 - A;
E = A * A - 5;
}

//And the rest SetB SetC...
};
The problem with this is that it's inefficent because the values need only
be calculated when they've to be displayed.
So, moving on, I may come to:
class SystemX
{
private:

enum { aA, bB, cC, dD, eE } specified_value ;

int value;

public:

void SetA(int in_A)
{
value = in_A;
specified_value = aA;
}

void SetB(int in_B)
{
value = in_B;
specified_value = bB;
}

void SetC(int in_C)
{
value = in_C:
specified_value = cC;
}

int GetA() const
{
switch ( specified_value )
{
case aA:

return value;

case bB:
//certain algorithm
case cC:
//ceratin algorithm
}
}

int GetB() const
{
switch ( specified_value )
{
case aA:
//certain algorithm
case bB:

return value;

case cC:
//certain algorithm
}

//and so on.
};
I'm not out-right saying that this is a bad method, but for the moment I'll
pursue an alternative. But.. before I get into that, I'd like advice on
splitting this class in half - I don't want the class that the GUI will work
with to even know about SetA, so would the following be advisable:

class SystemXInterfac e
{
public:

virtual int GetA() const = 0;
virtual int GetB() const = 0;
virtual int GetC() const = 0;
virtual int GetD() const = 0;
virtual int GetE() const = 0;
};
class SystemXImplemen tation : public System XInteface
{
void SetA(int); // ...
void SetB(int); // ...
}
How is this usually done? Is the above any good?
Annnnyyyyyway.. . at the moment, this is how my system is:
class SystemXInterfac e
{
protected:

int specified_value ;

public:

virtual int GetA() const = 0;
virtual int GetB() const = 0;
virtual int GetC() const = 0;
virtual int GetD() const = 0;
virtual int GetE() const = 0;

void SetSpecifiedVal ue(int in_specified_va lue)
{
specified_value = in_specified_va lue;
}

int GetSpecifiedVal ue(void) const
{
return specified_value ;
}

virtual ~SystemXInterfa ce() {}
};
class SystemXImp_Spec ifiedA
{
public:
virtual int GetA() const
{
return specified_value ;
}

virtual int GetB() const
{
//algorithm
}

virtual int GetC() const
{
//algorithm
}

//and so on
}

class SystemXImp_Spec ifiedB
{
public:
virtual int GetA() const
{
//algorithm
}

virtual int GetB() const
{
return specified_value ;
}

//and so on
}
And here's how I'm interacting with it:

void DisplaySystem(S ystemXInterface & intr)
{
cout << intr.GetA();
cout << intr.GetB();
cout << intr.GetC();
cout << intr.GetD();
cout << intr.GetE();

//Nice and simple!
}

int main()
{
//If you want to manipulate A, then

SystemXImp_Spec ifiedA blah(567);

DisplaySystem(b lah);

//If you want to manipulate D, then

SystemXIMp_Spec ifiedD blah(926);

blah.SetSpecifi edValue(437);

DisplaySystem(b lah);
}

Okay, so basically I'd just like all sorts of comments, questions and
suggestions. Like:

A) Should I leave the private member variable "specified_valu e" in my
SystemXInterfac e class, or should I put another class in between called
"SystemXImpleme ntation" and put the "specified_valu e" in that, and then make
the following relationship:

class SystemXInterfac e
{
public:

virtual int GetA() const = 0;
virtual int GetB() const = 0;
virtual int GetC() const = 0;
virtual int GetD() const = 0;
virtual int GetE() const = 0;
};
class SystemXImplemen tation : public SystemXInterfac e
{
protected:

int specified_value ;

public:

void SetSpecifiedVal ue(int in_specified_va lue)
{
specified_value = in_specified_va lue;
}

int GetSpecifiedVal ue(void)
{
return specified_value ;
}
};

class SystemXImp_Spec ifiedA : public SystemXImplemen tation
{
public:

virtual int GetA() const
{
return specified_value ;
}

virtual int GetB() const
{
//algorithm
}

virtual int GetC() const
{
//algorithm
}
};

class SystemImp_Speci fiedB : public SystemXImplemen tation
{
public:

virtual int GetA() const
{
//algorithm
}

virtual int GetB() const
{
return specified_value ;
}

virtual int GetC() const
{
//algorithm
}
}
Any thoughts?
B) Should I cache values? Or should I leave that up to the user. For example
if some calls GetB, and then later calls it again without the system having
changed, should I have it cached, or should I calculate it all over again,
ie. should it be built-in class behaviour or should it be the user's
problem?

C) Any other things, like how I should name my variables and classes.
Thanks!

-JKop

[Howard]

"JKop" <NU**@NULL.NULL > wrote in message
news:HP******** *********@news. indigo.ie...

void SetA(int in_A)
{
//Super algorithm

A = in_A;

B = A + 4;
C = A / 9;
D = 42 - A;
E = A * A - 5;
}

//And the rest SetB SetC...
};
The problem with this is that it's inefficent because the values need only
be calculated when they've to be displayed.

If all the values can be computed from any given other value (as in your
example, where they all depend on A), then you could always simplify things
greatly by simply storing a value from which everything else can be computed
(such as A, in this example). So, for example, if the user calls SetD, then
A would be 42 - D.

One note, however: in this *specific* example, you're losing information
when calculating C from A (since they're integers, and you're dividing).
That makes the system unsymetric (?), in that there are many possible values
of A that generate a single value of C, so calling SetC would result in
nondeterministi c behavior when trying to calculate A. (That is, if C is 1,
should A be 9, or 10, or 11, or...(up through 17)?) However, I'm guessing
these are just made-up examples, right? If your system does not have this
problem, then my solution would save you LOTS of effort, wouldn't it?

If you have more than one variable upon which the others depend, but which
are not themselves interdependant, then you would want to store more than
just one value. For example, using the electricty example, you're not
likely to actually change Current (I) or Power (W), but you *would* be
likely to change either Voltage (V) or Resistance (R). So you'd probably
store V and R, and calculate I and W.

But that example has a logical problem (which would exist in your solution,
too): how do you know which variable should change, if there are more than
one upon which the others depend? Say I call SetW(newW). Does that mean I
want to compute and alter R, or V? (Or both, by some other formula???)
Without more specifics, it's impossible to decide that, based solely on the
desire to change W. The interdependancy creates a paradox.

Of course, if everything depends on (can be computed from) only one specific
value, then there's no problem. Simply store that one value. Otherwise,
even given your rather complex solution, you're in a pickle. (Dill, I
think, perhaps with a hint of garlic.)

[By the way, is there actually a real problem you're trying to obtain a
solution for, or just playing with ideas? (Perhaps the answer lies in the
subject "Le Chatelier"...so mething about thermodynamic equilibrium, right?)]

-Howard

[JKop]

Howard posted:

However, I'm guessing these are just made-up
examples, right?
Correct. I should've stated that.
Of course, if everything depends on (can be computed from) only one
specific value, then there's no problem. Simply store that one value.
Otherwise, even given your rather complex solution, you're in a pickle.
(Dill, I think, perhaps with a hint of garlic.)

Yes, every other value can be calculated from one specific value, so yes, I
could just store one value.

But the thing is that the calculation details and algorithms are pretty
complicated, use a good bit of memory, and I'd lose precision if I used one
base value to calculate them all from.
[By the way, is there actually a real problem you're trying to obtain a
solution for, or just playing with ideas? (Perhaps the answer lies in
the subject "Le Chatelier"...so mething about thermodynamic equilibrium,
right?)]

You can apply it to pretty much anything.

In Chemistry in school, we learned it as the following:
Le Chatelier's priniciple:

When a stress is applied to a system at equilibrium, the system will
readjust to relieve the stress applied.

And we mostly applied it to chemical equilibrium.

So if you increase the temperature of a gas, the pressure goes up. If you
increase the volume of a gas the pressure goes down.
-JKop

[Dave Townsend]

This doesn't make sense. You seem to be omitting the possibility
that A might change, then B, etc. since once you setA then setB, you
completely lost the information about specifiedA, etc. In the type
of problem such as the gas equation PV = nRT, you need to immediately
recalculate the other variables when any of the others change.
What you might try instead is keep track of the changes on each variable,
and then only evaluate the new values when a get() is done. This might
be slighly more efficient because :

1. You may never do a get??() ever.
2. You can fold consequentive changes of one variable together, that is
setA( 1), setA(2) is equivalent to setA(2) ( well presuming that the
system depends only on the the values of A, etc, not their
derivatives,etc .
More optimistically, setA(1), setA(2), setA(1) folds down to setA(1),
and presuming the current value of A is X, setA(10), setA(X) is a nop.
3. There might be an "incrementa l" algorithm to recompute the new sytems
values from old ones based upon incremental differences in the independent
variables, or an iterative process to efficiently compute the new system.
With regard to implementing a system and a "GUI" helper class, I'd implement
this system class with a "dirty" flag, so as and when changes to the
independent
variables happen, I'd keep track of the sequences of changes and mark the
system
"dirty" meaning that the values will have to recomputed if anybody asks for
them.
When a get() is done, the new values are computed and dirtyflag is cleared.

Here's an outline of my idea....

#include "vector"
using namespace std;

class LeChatelier
{
public:
LeChatelier( int P , int V, int T, int N )
:_P(P), _V(V), _T(T), _N(N),
_dirty(false)
{}
public:
void setP( int P)
{
_dirty = true;
changes.push_ba ck( change(P, 'P'));
}
void setV( int V)
{
_dirty = true;
changes.push_ba ck( change(V, 'V'));
}
void setT( int T)
{
_dirty = true;
changes.push_ba ck( change(T, 'T'));
}
void setN( int N )
{
_dirty = true;
changes.push_ba ck( change(N, 'N'));
}
int getP()
{
if (_dirty)
updateValues();
return _P;
}
int getV()
{
if (_dirty)
updateValues();
return _V;
}
int getT()
{
if (_dirty)
updateValues();
return _T;
}
int getN()
{
if (_dirty)
updateValues();
return _N;
}
private:
int _P;
int _V;
int _T;
int _N;

bool _dirty;

struct change
{
int _value;
char _variable;

change( int value, char variable)
:_value(value), _variable(varia ble)
{}
change( const change& c )
:_value(c._valu e), _variable(c._va riable)
{}

};

vector< change > changes;
void updateValues()
{
for (int i=0; i< changes.size(); ++i )
{
switch( changes[i]._variable)
{
case 'P':
compute_from_P( changes[i]._value );
break;
case 'V':
compute_from_V( changes[i]._value );
break;
case 'T':
compute_from_T( changes[i]._value);
break;
case 'N':
compute_from_N( changes[i]._value);
break;

}
}
// purge change list and start over.
changes.clear() ;
_dirty=false;

}
void compute_from_P( int P )
{
// magic happens here...to update new values.

_P = P;

}
void compute_from_V( int V )
{

// magic happens here...to update new values.

_V=V;
}
void compute_from_T( int T )
{

// magic happens here...to update new values.

_T=T;
}
void compute_from_N( int N )
{

// magic happens here...to update new values.

_N=N;
}

};

int main(int argc, char* argv[])
{
LeChatelier lechatelier( 10, 11, 34, 30);

lechatelier.set P(20);
lechatelier.set P(25);
lechatelier.set T(400);
lechatelier.set V(22);

int newP = lechatelier.get P();
int newT = lechatelier.get T();
int newV = lechatelier.get V();

return 0;
}
A simple wrapper class for this object can be used by a GUI, the wrapper
class merely
forwarding calls to the gettters() in the system class.

"JKop" <NU**@NULL.NULL > wrote in message
news:HP******** *********@news. indigo.ie...

I have a "system", this system is 5 values:

A
B
C
D
E
Each of these values is dependant upon all others. If you want an analogy,
then take your pick:

A) Electricity: Current is proportional to Voltage, and also to Resistence

B) Gases: Volume is proportional to Pressure, and also to Temperature

So if one value changes, they all change.
Anyway, at then end of the whole design, I want my GUI to be able to just
work with it similar to the following:

cout << somesystem.GetA ();
cout << somesystem.GetB ();
cout << somesystem.GetC ();
cout << somesystem.GetD ();
cout << somesystem.GetE ();
I want to create a class to represent this system. The particular class with which the GUI will work doesn't need to have any Set functions, so the bare minimum would be:

class SystemX
{
public:

int GetA() const;
int GetB() const;
int GetC() const;
int GetD() const;
int GetE() const;
};

or maybe even:

class SystemX
{
public:

virtual int GetA() const = 0;
virtual int GetB() const = 0;
virtual int GetC() const = 0;
virtual int GetD() const = 0;
virtual int GetE() const = 0;
};
Now... in actually implementing this system, I *could* use 5 separate
variables and update them all at precisely the moment one of them changes.
Like so:

class SystemX
{
private:

int A;
int B;
int C;
int D;
int E;

public:

int GetA() const
{
return A;
}

int GetB() const
{
return B;
}

int GetC() const
{
return C;
}

void SetA(int in_A)
{
//Super algorithm

A = in_A;

B = A + 4;
C = A / 9;
D = 42 - A;
E = A * A - 5;
}

//And the rest SetB SetC...
};
The problem with this is that it's inefficent because the values need only
be calculated when they've to be displayed.
So, moving on, I may come to:
class SystemX
{
private:

enum { aA, bB, cC, dD, eE } specified_value ;

int value;

public:

void SetA(int in_A)
{
value = in_A;
specified_value = aA;
}

void SetB(int in_B)
{
value = in_B;
specified_value = bB;
}

void SetC(int in_C)
{
value = in_C:
specified_value = cC;
}

int GetA() const
{
switch ( specified_value )
{
case aA:

return value;

case bB:
//certain algorithm
case cC:
//ceratin algorithm
}
}

int GetB() const
{
switch ( specified_value )
{
case aA:
//certain algorithm
case bB:

return value;

case cC:
//certain algorithm
}

//and so on.
};
I'm not out-right saying that this is a bad method, but for the moment I'll pursue an alternative. But.. before I get into that, I'd like advice on
splitting this class in half - I don't want the class that the GUI will work with to even know about SetA, so would the following be advisable:

class SystemXInterfac e
{
public:

virtual int GetA() const = 0;
virtual int GetB() const = 0;
virtual int GetC() const = 0;
virtual int GetD() const = 0;
virtual int GetE() const = 0;
};
class SystemXImplemen tation : public System XInteface
{
void SetA(int); // ...
void SetB(int); // ...
}
How is this usually done? Is the above any good?
Annnnyyyyyway.. . at the moment, this is how my system is:
class SystemXInterfac e
{
protected:

int specified_value ;

public:

virtual int GetA() const = 0;
virtual int GetB() const = 0;
virtual int GetC() const = 0;
virtual int GetD() const = 0;
virtual int GetE() const = 0;

void SetSpecifiedVal ue(int in_specified_va lue)
{
specified_value = in_specified_va lue;
}

int GetSpecifiedVal ue(void) const
{
return specified_value ;
}

virtual ~SystemXInterfa ce() {}
};
class SystemXImp_Spec ifiedA
{
public:
virtual int GetA() const
{
return specified_value ;
}

virtual int GetB() const
{
//algorithm
}

virtual int GetC() const
{
//algorithm
}

//and so on
}

class SystemXImp_Spec ifiedB
{
public:
virtual int GetA() const
{
//algorithm
}

virtual int GetB() const
{
return specified_value ;
}

//and so on
}
And here's how I'm interacting with it:

void DisplaySystem(S ystemXInterface & intr)
{
cout << intr.GetA();
cout << intr.GetB();
cout << intr.GetC();
cout << intr.GetD();
cout << intr.GetE();

//Nice and simple!
}

int main()
{
//If you want to manipulate A, then

SystemXImp_Spec ifiedA blah(567);

DisplaySystem(b lah);

//If you want to manipulate D, then

SystemXIMp_Spec ifiedD blah(926);

blah.SetSpecifi edValue(437);

DisplaySystem(b lah);
}

Okay, so basically I'd just like all sorts of comments, questions and
suggestions. Like:

A) Should I leave the private member variable "specified_valu e" in my
SystemXInterfac e class, or should I put another class in between called
"SystemXImpleme ntation" and put the "specified_valu e" in that, and then make the following relationship:

class SystemXInterfac e
{
public:

virtual int GetA() const = 0;
virtual int GetB() const = 0;
virtual int GetC() const = 0;
virtual int GetD() const = 0;
virtual int GetE() const = 0;
};
class SystemXImplemen tation : public SystemXInterfac e
{
protected:

int specified_value ;

public:

void SetSpecifiedVal ue(int in_specified_va lue)
{
specified_value = in_specified_va lue;
}

int GetSpecifiedVal ue(void)
{
return specified_value ;
}
};

class SystemXImp_Spec ifiedA : public SystemXImplemen tation
{
public:

virtual int GetA() const
{
return specified_value ;
}

virtual int GetB() const
{
//algorithm
}

virtual int GetC() const
{
//algorithm
}
};

class SystemImp_Speci fiedB : public SystemXImplemen tation
{
public:

virtual int GetA() const
{
//algorithm
}

virtual int GetB() const
{
return specified_value ;
}

virtual int GetC() const
{
//algorithm
}
}
Any thoughts?
B) Should I cache values? Or should I leave that up to the user. For example if some calls GetB, and then later calls it again without the system having changed, should I have it cached, or should I calculate it all over again,
ie. should it be built-in class behaviour or should it be the user's
problem?

C) Any other things, like how I should name my variables and classes.
Thanks!

-JKop

[David Rubin]

JKop <NU**@NULL.NULL > wrote in message news:<HP******* **********@news .indigo.ie>...

I have a "system", this system is 5 values: [snip] Each of these values is dependant upon all others. [snip] Anyway, at then end of the whole design, I want my GUI to be able to just
work with it similar to the following:

cout << somesystem.GetA ();
cout << somesystem.GetB ();
cout << somesystem.GetC ();
cout << somesystem.GetD ();
cout << somesystem.GetE ();
This is a rqeuirement: provide accessors for each value.
I want to create a class to represent this system. The particular class with
which the GUI will work doesn't need to have any Set functions, so the bare
minimum would be:
[snip - only accessors]
You have to distinguish between *doesn't* *need* and *shouldn't* *be*
*able* *to*. Also, you need to determine whether or not you need a
protocol (abstract) class, or if you can just use a concrete class.
These decisions should be driven by your problem domain, expected
reuse of your classes, and the degree of insulation you want or need
to provide to clients of your classes.
Now... in actually implementing this system, I *could* use 5 separate
variables and update them all at precisely the moment one of them changes.

[snip - or I could calculate the values on demand, cache values, etc]

It's difficult to give advise about these kinds of optimizations
without knowing more details about the system you are implementing.
Just do something simple, and then do some performance testing later.
If you separate your implementation from your class definition (i.e.,
in a separate .c file), you can change the implementation at any time
without causing your clients to recompile.

As far as style issues go, just pick something that makes sense and
*be* *consistent*.

/david