matrices, mathematical programming

[tomamil]

imagine that you have different matrices with different names and you
want to perform the same action with each of them. is it possible to
put their names into some array and to create a loop that would call
their names right from the array and perform the desired operations
with the members of the matrices?

[santosh]

to*****@gmail.com wrote:

imagine that you have different matrices with different names and you
want to perform the same action with each of them. is it possible to
put their names into some array and to create a loop that would call
their names right from the array and perform the desired operations
with the members of the matrices?

No. You'll have to use an array of pointers for that purpose.
The program is probably poorly designed if repeated operations need to
be performed on several varyingly named objects. Use an array or linked
list of matrices.

[tomamil]

The program is probably poorly designed if repeated operations need to

be performed on several varyingly named objects. Use an array or linked
list of matrices.

the matrices are already three-dimensional. it's a finite element
problem, a lot of different matrices with integrals... i'll have a
closer look to find the way, thanks for direction...

[Chris Dollin]

to*****@gmail.com wrote:

imagine that you have different matrices with different names and you
want to perform the same action with each of them. is it possible to
put their names into some array and to create a loop that would call
their names right from the array and perform the desired operations
with the members of the matrices?

Why dink around with their /names/ when you could use their /addresses/?

If your matricies have type M, have an array of type pointer-to-M and
iterate along that.

static M *matrices[] = {&M1, &M2, &M3 ...};

void desired( M *matrix ) { ... }

.... for (i = 0; i < WHATEVER; i += 1) desired( matrices[i] ); ...

--
Chris "electric hedgehog" Dollin
Meaning precedes definition.

[Walter Roberson]

In article <11*********************@m58g2000cwm.googlegroups. com>,
santosh <sa*********@gmail.comwrote:

>The program is probably poorly designed if repeated operations need to
be performed on several varyingly named objects.

I don't seem to catch the reasoning on that "probably poorly designed" ?
Is it not the case that any for() or while loop involving more than
one variable has "repeated operations" that "need to be performed
on several varyingly named objects" ?

Even if you meant to only talk about performing "the same operation"
on several different objects, I can think of many occasions when I would
not deem it "poor design" to perform "the same operation" on multiple
variables. Adding a routine to perform the operation on a single
variable and then calling the routine repeatedly usually does not come
for free.

Consider for example the simple example of having a long list of
[x,y] pairs and that the x and y values must be individually summed.
If one uses a routine to total one of the components and calls it
twice, then the long list must be traversed twice, with all the cache
effects that implies -- and if it is a linked list, with noticable
pointer work. Is it really such a bad design to use a single
routine that iterates over all the members and sums the
"several varyingly named objects" in individual statements? Is
the meaning unclear? Is it hard to debug or maintain or document?
Worse than introducing a new auxillary routine just for this
one purpose?
--
There are some ideas so wrong that only a very intelligent person
could believe in them. -- George Orwell

[tomamil]

thank you all. this was the first time i posted anything here and i see
i can meet good people around here... thanks a lot for your help...

On Jan 26, 3:20 pm, Chris Dollin <[e-mail]:

[e-mail] wrote:

imagine that you have different matrices with different names and you
want to perform the same action with each of them. is it possible to
put their names into some array and to create a loop that would call
their names right from the array and perform the desired operations
with the members of the matrices?Why dink around with their /names/ when you could use their /addresses/?

If your matricies have type M, have an array of type pointer-to-M and
iterate along that.

static M *matrices[] = {&M1, &M2, &M3 ...};

void desired( M *matrix ) { ... }

.... for (i = 0; i < WHATEVER; i += 1) desired( matrices[i] ); ...

--
Chris "electric hedgehog" Dollin
Meaning precedes definition.

[santosh]

Walter Roberson wrote:

In article <11*********************@m58g2000cwm.googlegroups. com>,
santosh <sa*********@gmail.comwrote:

The program is probably poorly designed if repeated operations need to
be performed on several varyingly named objects.

I don't seem to catch the reasoning on that "probably poorly designed" ?
Is it not the case that any for() or while loop involving more than
one variable has "repeated operations" that "need to be performed
on several varyingly named objects" ?

No. The OP wanted to repeatedly process multiple objects by using their
*name*. That is, IMHO, poor design. Lets say you have a series of
objects called o1, o2, ..., oN. The OP was asking, as far as I can
figure out from his post, if it was possible to store these identifiers
in an array, and pass them, one by one, to the processing function.
This is not possible in C, so I suggested that he use an array of
pointers to these objects, or a linked list, to pass them around to
various functions.

Even if you meant to only talk about performing "the same operation"
on several different objects, I can think of many occasions when I would
not deem it "poor design" to perform "the same operation" on multiple
variables. Adding a routine to perform the operation on a single
variable and then calling the routine repeatedly usually does not come
for free.

You're quite right in pointing out the above. My choice of wording was
really bad. I didn't mean to imply that performing repeated operations
on varyingly named objects was bad, just that attempting to use each
one by it's name, instead of by means of pointers, was probably poor
design.

Reading over my own post, I realise I ended up seeming to mean
something totally different.

[tomamil]

on varyingly named objects was bad, just that attempting to use each

one by it's name, instead of by means of pointers, was probably poor
design.

yes, it is a sign of poor design. i agree....

[CBFalconer]

to*****@gmail.com wrote:

>
thank you all. this was the first time i posted anything here and
i see i can meet good people around here... thanks a lot for your
help...

Please do not top-post. Your answer belongs after (or intermixed
with) the (snipped) material to which you reply. The snipping
removes anything immaterial to your reply. See the following
links.

--
Some informative links:
<http://www.catb.org/~esr/faqs/smart-questions.html>
<http://www.caliburn.nl/topposting.html>
<http://www.netmeister.org/news/learn2quote.html>
<http://cfaj.freeshell.org/google/ (taming google)
<http://members.fortunecity.com/nnqweb/ (newusers)

[Malcolm McLean]

<to*****@gmail.comwrote in message

imagine that you have different matrices with different names and you
want to perform the same action with each of them. is it possible to
put their names into some array and to create a loop that would call
their names right from the array and perform the desired operations
with the members of the matrices?

C binds identifiers at compile time.

Or, in less geeky terms, all the human-readbale labels you use for your
matrices are thrown away, and the computer just works on addresses.

Whilst it is possible to fudge up some name binding system, by turning the
names into strings and implenting a look-up table, if you need to do this
then C is probably not the right language for your problem.
However most functions to tkae lists of matrices can be written without
names

eg

super_op(double **matrices, int *width, int *height, int Nmatrices)

Then you have to do all the row|column converions to offsets manually