Dynamic Variables

#define a (c / b)

I don''t know of any programming language that supports "Dynamic Varaibles".
But how can 5/5 be 0?

Minor thing, forget it.

Hmm... Interesting idea though. One could write a C++ class or something

It actually would be VERY useful in game programming (THe truth)

sounds alot like references
maybe
int &a = (c/b);
would work...not sure though

quote:

---

Original post by barazor
sounds alot like references
maybe
int &a = (c/b);
would work...not sure though

---

Blahh.. Maybe! I've got to test this out!



Edited by - MindFlayer on December 31, 2001 4:47:27 PM

Maybe that class would accept a string operator and will recalculate again and again?

Maybe the only viable solution so far is Martee''s #define?

Your class would need to create a thread and periodically poll the values of variables it was assigned to monitor - useless overhead. If the variable was a symbolic alias (meaning that it was replaced by the actual values at compile time), then it would work but would introduce some new problems.

I think it''s easier to simply notify any "watcher" variables whenever code modifies a variable''s value.

[ GDNet Start Here | GDNet FAQ | MS RTFM | STL | Google ]
Thanks to Kylotan for the idea!

that would suck because a b c would be public.

maybe you could do this:

inline float DyncamicA(){
static float* a;
static float* b;

return (a / b );
}

i dont know i dont do inline often.
you would also need to initialize ur pointers somehow. maybe you could use a template or something too.

Build an expression tree. When you want the value of a, evaluate the tree and it will give you the right answer, even if you change the other values.

Now if we could only do:

dynamic((type)*variable,char*expression)... that''d be the day

Slight chance it might come in Python 2.3

You can do it in C++, today with most compilers, by defining a property get method and having it calculate the result as needed.

Wiht MSVC you'd do this:

class MyClass { __declspec(property(get=a)) float fakeProperty; float a() { return b/c; } }; And use set property accessors to set a boolean flag indicating that you need to recalculate.

Edited by - Magmai Kai Holmlor on January 1, 2002 5:47:46 AM

Off the top of my head.

#include <iostream> using namespace std; class DynamicQuotient<typename T> { public: // notice, I take references to the numbers, so that I can ''see'' any changes made to them // notice also this requires me to use initialization rather than assignment DynamicQuotient(T& numerator, T& denominator) : n(numerator), d(denominator) {} T operator()(void) { return n / d; } // is this the syntax for user-defined casts? I can never remember T operator T { return n / d; } private: // notice, they''re references T& n; T& d; }; int main(int, char**) { double a, b; DynamicQuotient<double> c(a, b); a = 3; b = 4; cout << "the value of c is " << c() << endl; a = 5; cout << "the value of c is " << (double)c << endl; // etc }

You would have to be really careful that the scope of the dynamic variable matched (or was less than) the scope of the variables it refers to. If they go out of scope but it doesn''t, its references are now broken and your program ought to crash.

It could be fairly simply altered to instead of being a division to take a functor object, describing a binary function that could operate on both values. You could probably also chain them.

But, what I need is that I need is so that any variable could be used by that class.

You are all boneheads! j/k! Really, here''s how you do it.

You use a DAG. It''s a Directed Acyclic Graph based on dependencies. Each variable is a node in the graph. Any variable which changes value then propogates downstream in the graph. Updates only occur as needed and always occur when needed.

To be more precise regarding the DAG, when a variable changes value, it propogates downstream that it changed value, but not what the rippling value change is. This is necessary for arrays, as we don't want to recalculate a whole array downstream, we just want to inform descendants in the DAG that they are no longer valid. One flag indicates a whole array is no longer valid.

When a value is required, we check to see if it has been flagged as out of date. If it is, we propogate upstream, recalulating until an ancestor is encountered that is still up to date, making it unnecessary to recalculate up to date ancestors.

If only one element of a whole array needs to be recalculated, this method serves that purpose. Arrays could also be flagged as 'calculate all at once', or only 'on a case by case' basis. This would be the programmer's decision, depending on the purpose of the array.

Edited by - bishop_pass on January 1, 2002 1:20:01 PM

Please mr. 45 year old, show us the code to do so!