matrix 2x2

[wojtas.wtk]

How write class of matrix 2x2 acted following program in order to?

int main(int argc, char **argv)
{
const double tab[][2]= {{1.5, 2.5}, {3.5, 4.5}};

matrix2x2 a(tab), b(1.0, 0.0, 0.0, -1.0), c = a + b, d;

d = -c;

cout << "\n matrix a: " << a;
cout << ", matrix b: " << b;
cout << ", matrix c: " << c;
cout << ", matrix d: " << d;
cout << ", det a: " << a.det();
cout << ", det b: " << b.det();
cout << ", det c: " << c.det();
cout << ", det d: " << d.det();

return 0;
}

[Daniel T.]

In article <11*********************@j33g2000cwa.googlegroups. com>,
wo********@gmail.com wrote:

How write class of matrix 2x2 acted following program in order to?

int main(int argc, char **argv)
{
const double tab[][2]= {{1.5, 2.5}, {3.5, 4.5}};

matrix2x2 a(tab), b(1.0, 0.0, 0.0, -1.0), c = a + b, d;

d = -c;

cout << "\n matrix a: " << a;
cout << ", matrix b: " << b;
cout << ", matrix c: " << c;
cout << ", matrix d: " << d;
cout << ", det a: " << a.det();
cout << ", det b: " << b.det();
cout << ", det c: " << c.det();
cout << ", det d: " << d.det();

return 0;
}

Simple. Read the first compiler error you get when you try to compile
the above, then write some code that will fix the error, recompile.
Repeat until no compiler errors occur. Then do the same with the link
errors, then you are done.
--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.

[Martin Jørgensen]

wo********@gmail.com wrote:

How write class of matrix 2x2 acted following program in order to?

int main(int argc, char **argv)
{
const double tab[][2]= {{1.5, 2.5}, {3.5, 4.5}};

matrix2x2 a(tab), b(1.0, 0.0, 0.0, -1.0), c = a + b, d;

d = -c;

cout << "\n matrix a: " << a;
cout << ", matrix b: " << b;
cout << ", matrix c: " << c;
cout << ", matrix d: " << d;
cout << ", det a: " << a.det();
cout << ", det b: " << b.det();
cout << ", det c: " << c.det();
cout << ", det d: " << d.det();

return 0;
}

Wow! If that's the best you can do, I suggest you start with something
much simpler... I've only been programming in C++ for about 3 months but
at least I could do the above code much better than you.

In case you're really lost, you could start with a text-book on c++ and
make a "hello world"-program and do the exercises.

I don't think anyone wants to give you the complete solution to your
problem when you present a program that lacks so much...

For instance: Where's your matrix2x2 class? Do you think your program
will compile as it looks now?
Best regards / Med venlig hilsen
Martin Jørgensen

--
---------------------------------------------------------------------------
Home of Martin Jørgensen - http://www.martinjoergensen.dk

[Daniel T.]

In article <g7************@news.tdc.dk>,
Martin Jørgensen <un*********@spam.jay.net> wrote:

wo********@gmail.com wrote:

How write class of matrix 2x2 acted following program in order to?

int main(int argc, char **argv)
{
const double tab[][2]= {{1.5, 2.5}, {3.5, 4.5}};

matrix2x2 a(tab), b(1.0, 0.0, 0.0, -1.0), c = a + b, d;

d = -c;

cout << "\n matrix a: " << a;
cout << ", matrix b: " << b;
cout << ", matrix c: " << c;
cout << ", matrix d: " << d;
cout << ", det a: " << a.det();
cout << ", det b: " << b.det();
cout << ", det c: " << c.det();
cout << ", det d: " << d.det();

return 0;
}

Wow! If that's the best you can do, I suggest you start with something
much simpler... I've only been programming in C++ for about 3 months but
at least I could do the above code much better than you.

In case you're really lost, you could start with a text-book on c++ and
make a "hello world"-program and do the exercises.

I don't think anyone wants to give you the complete solution to your
problem when you present a program that lacks so much...

For instance: Where's your matrix2x2 class? Do you think your program
will compile as it looks now?

Martin,

Not so harsh on the newbies. :-) Actually, he has an excellent start
in that he knows what the interface of his class should look like, and
that should always be the first thing you figure out.
--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.

[Martin Jørgensen]

Daniel T. wrote:

In article <g7************@news.tdc.dk>,
Martin Jørgensen <un*********@spam.jay.net> wrote: -snip-
Martin,

Not so harsh on the newbies. :-) Actually, he has an excellent start
in that he knows what the interface of his class should look like, and
that should always be the first thing you figure out.

Uh, sorry... I thought perhaps it was some homework exercise and would
appreciate some more specific questions other than "this doesn't work, I
need a solution. Please give me a complete solution, so I don't have to
think". :-)

But you have a really good point, and I can also remember how it is to
be a newbie. So, I am willing to help with problems, if the OP posts his
problems... I can probably learn something still... :-)

This is untested but I believe he could/perhaps should start with
something like:
class matrix2x2
{
private:
// private variables here
double m1, m2, m3, m4;

public:
// member functions and constructur goes in here
matrix2x2() : m1(0), m2(0), m3(0), m4(0) { }

matrix2x2(double mat1, double mat2, double mat3, double mat4) :
m1(mat1), m2(mat2), m3(mat3), m4(mat4) { }
// initialize variables...

det()
{ // insert code for calculating determinant here
}

matrix2x2 operator + (matrix2x2 m1, matrix2x2 m2)
{
// operator overloading of plus "+" <- insert code here
}

(return type) operator << (.... bla. bla.)
{
// operator overloading of plus "<<" <- insert code here
}
}
But I didn't test it... I would like to see what OP ends up with... At
least there should be something to work on now... And we can answer any
questions that arise, I think... The most difficult part (at least for
me) would be overloading this "<<"-thing. AFAIR it has something to do
with streams and I would have to look that up in my book in order to
figure that part out.

I guess one could also declare a 2D array in the private-part of the
class, so it works more like this: const double tab[][2]= {{1.5, 2.5},
{3.5, 4.5}};

Best regards / Med venlig hilsen
Martin Jørgensen

--
---------------------------------------------------------------------------
Home of Martin Jørgensen - http://www.martinjoergensen.dk

[Daniel T.]

In article <dt************@news.tdc.dk>,
Martin Jørgensen <un*********@spam.jay.net> wrote:

Daniel T. wrote:

In article <g7************@news.tdc.dk>,
Martin Jørgensen <un*********@spam.jay.net> wrote: -snip-

Martin,

Not so harsh on the newbies. :-) Actually, he has an excellent start
in that he knows what the interface of his class should look like, and
that should always be the first thing you figure out.

Uh, sorry... I thought perhaps it was some homework exercise and would
appreciate some more specific questions other than "this doesn't work, I
need a solution. Please give me a complete solution, so I don't have to
think". :-)

But you have a really good point, and I can also remember how it is to
be a newbie. So, I am willing to help with problems, if the OP posts his
problems... I can probably learn something still... :-)

The thing is, I think his assignment was to come up with the interface
(ie exactly what you did.) By all means do other people's homework if it
seems at all challenging (you can learn a lot from that,) but try to
just post hints to the OP after you get it done.
This is untested but I believe he could/perhaps should start with
something like:
class matrix2x2
{
private:
// private variables here
double m1, m2, m3, m4;

public:
// member functions and constructur goes in here
matrix2x2() : m1(0), m2(0), m3(0), m4(0) { }

matrix2x2(double mat1, double mat2, double mat3, double mat4) :
m1(mat1), m2(mat2), m3(mat3), m4(mat4) { }
// initialize variables...

det()
{ // insert code for calculating determinant here
}

matrix2x2 operator + (matrix2x2 m1, matrix2x2 m2)
{
// operator overloading of plus "+" <- insert code here
}

(return type) operator << (.... bla. bla.)
{
// operator overloading of plus "<<" <- insert code here
}
}
But I didn't test it... I would like to see what OP ends up with... At
least there should be something to work on now... And we can answer any
questions that arise, I think... The most difficult part (at least for
me) would be overloading this "<<"-thing. AFAIR it has something to do
with streams and I would have to look that up in my book in order to
figure that part out.

I guess one could also declare a 2D array in the private-part of the
class, so it works more like this: const double tab[][2]= {{1.5, 2.5},
{3.5, 4.5}};

I would use a one dimensional array over a two dimensional one, but what
you have is fine.

Of course, 'det' needs a return type. I would put the operator+ outside
the class since it doesn't work on 'this', and operator<< needs to be
outside the class as well:

ostream& operator<<( ostream& os, matrix2x2 mat ) {
return os << //... blah, blah...
}

--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.

[Martin Jørgensen]

Daniel T. wrote:

In article <dt************@news.tdc.dk>,
Martin Jørgensen <un*********@spam.jay.net> wrote: -snip-
The thing is, I think his assignment was to come up with the interface
(ie exactly what you did.) By all means do other people's homework if it
seems at all challenging (you can learn a lot from that,) but try to
just post hints to the OP after you get it done.
Yep, agreed. But I'm also a bit busy working on my own bs.c project so I
hope the OP soon will come with some new inputs :-)

This is untested but I believe he could/perhaps should start with
something like:
class matrix2x2
{
private:
// private variables here
double m1, m2, m3, m4;

public:
// member functions and constructur goes in here
matrix2x2() : m1(0), m2(0), m3(0), m4(0) { }

matrix2x2(double mat1, double mat2, double mat3, double mat4) :
m1(mat1), m2(mat2), m3(mat3), m4(mat4) { }
// initialize variables...

det()
{ // insert code for calculating determinant here
}

matrix2x2 operator + (matrix2x2 m1, matrix2x2 m2)
{
// operator overloading of plus "+" <- insert code here
}

(return type) operator << (.... bla. bla.)
{
// operator overloading of plus "<<" <- insert code here
}
}
But I didn't test it... I would like to see what OP ends up with... At
least there should be something to work on now... And we can answer any
questions that arise, I think... The most difficult part (at least for
me) would be overloading this "<<"-thing. AFAIR it has something to do
with streams and I would have to look that up in my book in order to
figure that part out.

I guess one could also declare a 2D array in the private-part of the
class, so it works more like this: const double tab[][2]= {{1.5, 2.5},
{3.5, 4.5}};

I would use a one dimensional array over a two dimensional one, but what
you have is fine.

How is that... "a one-dim. array over a two-dim. array"?

The problem with what I posted is likely that it's not possible to scale
up the solution in order to add something like 3x3 matrixes... But at
least he got something to look at and modify...
Of course, 'det' needs a return type. I would put the operator+ outside
the class since it doesn't work on 'this', and operator<< needs to be
outside the class as well:
Oh... I thought it didn't matter if it were inside or outside the class...?
ostream& operator<<( ostream& os, matrix2x2 mat ) {
return os << //... blah, blah...
}

Oh, yeah... This I couldn't remember but I could have looked it up, but
then again I think it's the OP who should try to solve this problem
before I do it :-)

At least he got plenty of hints to get started now, I think :-)

And this is actually a "funny" exercise I think, so he don't have any
excuses for not posting his solution (or his attempt to get a solution)...
Best regards / Med venlig hilsen
Martin Jørgensen

--
---------------------------------------------------------------------------
Home of Martin Jørgensen - http://www.martinjoergensen.dk

[Daniel T.]

In article <jd************@news.tdc.dk>,
Martin Jørgensen <un*********@spam.jay.net> wrote:

Daniel T. wrote:

I would use a one dimensional array over a two dimensional one, but what
you have is fine.

How is that... "a one-dim. array over a two-dim. array"?

class maatrix2x2 {
double m[4];
public:
//...
};

Of course, 'det' needs a return type. I would put the operator+ outside
the class since it doesn't work on 'this', and operator<< needs to be
outside the class as well:

Oh... I thought it didn't matter if it were inside or outside the class...?

You can put any function inside the class but why? If the only functions
in the class are ones that use "this" then your interface will be
cleaner, and intentions will be pure.
--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.

[Martin Jørgensen]

Daniel T. wrote:
-snip-

Ok...

Seems like the OP perhaps isn't interested in learning C++ anyway or he
was only interested in a solution?
Best regards / Med venlig hilsen
Martin Jørgensen

--
---------------------------------------------------------------------------
Home of Martin Jørgensen - http://www.martinjoergensen.dk