www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - struct inheritance need?

reply Weed <resume755 mail.ru> writes:
I should explain why it's important for me:

For example, I am making a matrix object(s)

It should be:
- any size
- with ability of making matrix instance of a given size in compile time.
- ability of creating matrix instance in runtime.

I have decided to make it struct because I need to create matrix
object in compile time. in real program I'll need matricies of
variable size and 3х1, 3х3, 6х6, 3х6 sizes (and may be other).

I want to make matrix template and insert in it with mixin operator
several structures of different sizes (and this structs are not store 
his dimensions in each instance, of course: variables width and height 
declared as invariant). By doing this I'll get several different 
structures  (matrix_dynamic, matrix3x3, matrix6x6 etc)

question is how those matricies can interoperate? They does not have
common parent (structures does not have inheritance) , so I can't
make common function for matricies of different sizes opAdd for
example, and have to do functions for all types of matricies.

How should I implement such a class In D properly?  	
It possible in C++, but I like some of the language D
Dec 16 2008
next sibling parent reply "Bill Baxter" <wbaxter gmail.com> writes:
MjAwOC8xMi8xNiBXZWVkIDxyZXN1bWU3NTVAbWFpbC5ydT46Cj4gSSBzaG91bGQgZXhwbGFpbiB3
aHkgaXQncyBpbXBvcnRhbnQgZm9yIG1lOgo+Cj4gRm9yIGV4YW1wbGUsIEkgYW0gbWFraW5nIGEg
bWF0cml4IG9iamVjdChzKQo+Cj4gSXQgc2hvdWxkIGJlOgo+IC0gYW55IHNpemUKPiAtIHdpdGgg
YWJpbGl0eSBvZiBtYWtpbmcgbWF0cml4IGluc3RhbmNlIG9mIGEgZ2l2ZW4gc2l6ZSBpbiBjb21w
aWxlIHRpbWUuCj4gLSBhYmlsaXR5IG9mIGNyZWF0aW5nIG1hdHJpeCBpbnN0YW5jZSBpbiBydW50
aW1lLgo+Cj4gSSBoYXZlIGRlY2lkZWQgdG8gbWFrZSBpdCBzdHJ1Y3QgYmVjYXVzZSBJIG5lZWQg
dG8gY3JlYXRlIG1hdHJpeAo+IG9iamVjdCBpbiBjb21waWxlIHRpbWUuIGluIHJlYWwgcHJvZ3Jh
bSBJJ2xsIG5lZWQgbWF0cmljaWVzIG9mCj4gdmFyaWFibGUgc2l6ZSBhbmQgM8gxLCAzyDMsIDbI
NiwgM8g2IHNpemVzIChhbmQgbWF5IGJlIG90aGVyKS4KPgo+IEkgd2FudCB0byBtYWtlIG1hdHJp
eCB0ZW1wbGF0ZSBhbmQgaW5zZXJ0IGluIGl0IHdpdGggbWl4aW4gb3BlcmF0b3IKPiBzZXZlcmFs
IHN0cnVjdHVyZXMgb2YgZGlmZmVyZW50IHNpemVzIChhbmQgdGhpcyBzdHJ1Y3RzIGFyZSBub3Qg
c3RvcmUgaGlzCj4gZGltZW5zaW9ucyBpbiBlYWNoIGluc3RhbmNlLCBvZiBjb3Vyc2U6IHZhcmlh
YmxlcyB3aWR0aCBhbmQgaGVpZ2h0IGRlY2xhcmVkCj4gYXMgaW52YXJpYW50KS4gQnkgZG9pbmcg
dGhpcyBJJ2xsIGdldCBzZXZlcmFsIGRpZmZlcmVudCBzdHJ1Y3R1cmVzCj4gIChtYXRyaXhfZHlu
YW1pYywgbWF0cml4M3gzLCBtYXRyaXg2eDYgZXRjKQo+Cj4gcXVlc3Rpb24gaXMgaG93IHRob3Nl
IG1hdHJpY2llcyBjYW4gaW50ZXJvcGVyYXRlPyBUaGV5IGRvZXMgbm90IGhhdmUKPiBjb21tb24g
cGFyZW50IChzdHJ1Y3R1cmVzIGRvZXMgbm90IGhhdmUgaW5oZXJpdGFuY2UpICwgc28gSSBjYW4n
dAo+IG1ha2UgY29tbW9uIGZ1bmN0aW9uIGZvciBtYXRyaWNpZXMgb2YgZGlmZmVyZW50IHNpemVz
IG9wQWRkIGZvcgo+IGV4YW1wbGUsIGFuZCBoYXZlIHRvIGRvIGZ1bmN0aW9ucyBmb3IgYWxsIHR5
cGVzIG9mIG1hdHJpY2llcy4KPgo+IEhvdyBzaG91bGQgSSBpbXBsZW1lbnQgc3VjaCBhIGNsYXNz
IEluIEQgcHJvcGVybHk/Cj4gSXQgcG9zc2libGUgaW4gQysrLCBidXQgSSBsaWtlIHNvbWUgb2Yg
dGhlIGxhbmd1YWdlIEQKPgoKSGVyZSdzIG9uZSB3YXk6Cmh0dHA6Ly93d3cuZHNvdXJjZS5vcmcv
cHJvamVjdHMvb3Blbm1lc2hkL2Jyb3dzZXIvdHJ1bmsvTGluQWxnL2xpbmFsZy9NYXRyaXhULmQK
Ci0tYmIK
Dec 16 2008
parent Weed <resume755 mail.ru> writes:
Bill Baxter пишет:

 2008/12/16 Weed <resume755 mail.ru>:

 I should explain why it's important for me:

 For example, I am making a matrix object(s)

 It should be:
 - any size
 - with ability of making matrix instance of a given size in compile time.
 - ability of creating matrix instance in runtime.

 I have decided to make it struct because I need to create matrix
 object in compile time. in real program I'll need matricies of
 variable size and 3х1, 3х3, 6х6, 3х6 sizes (and may be other).

 I want to make matrix template and insert in it with mixin operator
 several structures of different sizes (and this structs are not store his
 dimensions in each instance, of course: variables width and height declared
 as invariant). By doing this I'll get several different structures
  (matrix_dynamic, matrix3x3, matrix6x6 etc)

 question is how those matricies can interoperate? They does not have
 common parent (structures does not have inheritance) , so I can't
 make common function for matricies of different sizes opAdd for
 example, and have to do functions for all types of matricies.

 How should I implement such a class In D properly?
 It possible in C++, but I like some of the language D



 Here's one way:
 http://www.dsource.org/projects/openmeshd/browser/trunk/LinAlg/linalg/MatrixT.d
 
 --bb



necessarily need the ability to change the size of the matrix

together with a static matrix it can be done using two types of matrices 
with a single parent.
Dec 16 2008
prev sibling next sibling parent reply Weed <resume755 mail.ru> writes:
Weed пишет:

 I should explain why it's important for me:
 
 For example, I am making a matrix object(s)
 
 It should be:
 - any size
 - with ability of making matrix instance of a given size in compile time.
 - ability of creating matrix instance in runtime.
 
 I have decided to make it struct because I need to create matrix
 object in compile time. in real program I'll need matricies of
 variable size and 3х1, 3х3, 6х6, 3х6 sizes (and may be other).
 
 I want to make matrix template and insert in it with mixin operator
 several structures of different sizes (and this structs are not store 
 his dimensions in each instance, of course: variables width and height 
 declared as invariant). By doing this I'll get several different 
 structures  (matrix_dynamic, matrix3x3, matrix6x6 etc)
 
 question is how those matricies can interoperate? They does not have
 common parent (structures does not have inheritance) , so I can't
 make common function for matricies of different sizes opAdd for
 example, and have to do functions for all types of matricies.
 
 How should I implement such a class In D properly?     
 It possible in C++, but I like some of the language D




I think could help a static creation objects of classes (including 
compile-time creation), but it is also impossible now.
For example:

MatrixClass a(3,2);
static MatrixClass a(3,2);

Planned in the future to implement inheritance of structs or the static 
creation of classes?
Dec 16 2008
next sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Weed:

 Planned in the future to implement inheritance of structs or the static 
 creation of classes?



Inheritance of structs: I think it's not planned. Structs in D are meant to be
used for different things than classes.
Yet, as time passes structs are gaining more power: you can't believe that very
recently they have gained constructors/destructors too in D2. Probably in a
system language conceptual purity isn't much appreciated :-)

Static creation of classes (I think you mean creation of objects): it sounds
like an interesting thing, I know of a system language that allows the creation
of objects only at compile-time, and at compile-time it also performs several
space optimizations among such objects (and such space optimizations often
improve running speed a little).

Bye,
bearophile
Dec 16 2008
parent reply Weed <resume755 mail.ru> writes:
bearophile пишет:

 Weed:

 Planned in the future to implement inheritance of structs or the 







 Inheritance of structs: I think it's not planned. Structs in D are




 Yet, as time passes structs are gaining more power: you can't believe



Probably in a system language conceptual purity isn't much appreciated :-)



I believe that the opportunity to place an object in memory, stack or 
heap is more important than the struggle against "splicing".

I think not worth taking structs and classes from C#. May be bytecode 
interpreter C# does not show the difference in speed between the 
allocation of memory by a small object + its using and the use of a 
static object, so developers C# decided to do so as done. (but I am not 
a specialist in the design of compilers :))


 Static creation of classes (I think you mean creation of objects): it
 sounds like an interesting thing, I know of a system language that
 allows the creation of objects only at compile-time, and at
 compile-time it also performs several space optimizations among such
 objects (and such space optimizations often improve running speed a
 little).



And in fact we come to making structs and classes similar except that 
classes can not be assigned by value.

Such an option I like.



 Dec 16 2008



  parent reply Yigal Chripun <yigal100 gmail.com>  writes:


Weed wrote:

 bearophile пишет:
  > Weed:
  >> Planned in the future to implement inheritance of structs or the
 static creation of classes?
  >
  > Inheritance of structs: I think it's not planned. Structs in D are
 meant to be used for different things than classes.
  > Yet, as time passes structs are gaining more power: you can't believe
  >
 that very recently they have gained constructors/destructors too in D2.
 Probably in a system language conceptual purity isn't much appreciated :-)
  >

 I believe that the opportunity to place an object in memory, stack or
 heap is more important than the struggle against "splicing".

 I think not worth taking structs and classes from C#. May be bytecode
 interpreter C# does not show the difference in speed between the
 allocation of memory by a small object + its using and the use of a
 static object, so developers C# decided to do so as done. (but I am not
 a specialist in the design of compilers :))

  > Static creation of classes (I think you mean creation of objects): it
  > sounds like an interesting thing, I know of a system language that
  > allows the creation of objects only at compile-time, and at
  > compile-time it also performs several space optimizations among such
  > objects (and such space optimizations often improve running speed a
  > little).

 And in fact we come to making structs and classes similar except that
 classes can not be assigned by value.

 Such an option I like.



If I understand you correctly - I think you confuse here two separate 
and orthogonal issues.
1) struct vs. class
2) memory allocation

What D tries to do is to provide types with value semantics via structs 
and types with reference semantics _and_polymorphism_ via classes.
IMO C++ is a prime example how to not design a language and the slicing 
problem is a good example of that. value types should not have 
polymorphism whatsoever as is done in D.

memory allocation is orthogonal to this:
class C {...}
Struct S {...}

auto c1 = new C; // classes default to heap alloc
scope c2 = new C; // c2 is on stack
S s1; // structs default to stack
auto s2 = new S; // s2 is S* (heap alloc)

I think Andrei said he wants to make changes to "scope", that is IIRC.

struct inheritance, if it gets implemented in D, should express IMO 
semantics similar to concepts as in C++0x, not provide polymorphism for 
value types which is clearly a mistake. (also this will remove the need 
for typedefs, isn't it?)



 Dec 16 2008



  parent reply Weed <resume755 mail.ru>  writes:


Yigal Chripun пишет:


 
 If I understand you correctly - I think you confuse here two separate 
 and orthogonal issues.
 1) struct vs. class
 2) memory allocation
 
 What D tries to do is to provide types with value semantics via structs 
 and types with reference semantics _and_polymorphism_ via classes.
 IMO C++ is a prime example how to not design a language and the slicing 
 problem is a good example of that. value types should not have 
 polymorphism whatsoever as is done in D.
 
 memory allocation is orthogonal to this:
 class C {...}
 Struct S {...}
 
 auto c1 = new C; // classes default to heap alloc
 scope c2 = new C; // c2 is on stack
 S s1; // structs default to stack
 auto s2 = new S; // s2 is S* (heap alloc)
 
 I think Andrei said he wants to make changes to "scope", that is IIRC.
 



What will change?


 struct inheritance, if it gets implemented in D, should express IMO 
 semantics similar to concepts as in C++0x, not provide polymorphism for 
 value types which is clearly a mistake. (also this will remove the need 
 for typedefs, isn't it?)



I agree.
In my case I chose to structure rather than a class because it can be 
initialized at compile time.

But now I thing must be allowed to deploy class in the default data 
segment. And add the possibility of creating a object of class at 
compile time.
	
Nothing prevents this change?



 Dec 16 2008



  parent reply Kagamin <spam here.lot>  writes:


Weed Wrote:


 I agree.
 In my case I chose to structure rather than a class because it can be 
 initialized at compile time.
 
 But now I thing must be allowed to deploy class in the default data 
 segment. And add the possibility of creating a object of class at 
 compile time.



If you want to use full blown OOP, class is your choise. There are static
constructors for static initialization.



 Dec 17 2008



  parent reply Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 I agree.
 In my case I chose to structure rather than a class because it can be 
 initialized at compile time.

 But now I thing must be allowed to deploy class in the default data 
 segment. And add the possibility of creating a object of class at 
 compile time.



 If you want to use full blown OOP, class is your choise. There are static
constructors for static initialization.



There does not need a static initialization of static members of the 
class. There must be able to create objects of classes at compile time.



 Dec 17 2008



 next sibling parent  Weed <resume755 mail.ru>  writes:


Weed пишет:

 Kagamin пишет:

 Weed Wrote:


 I agree.
 In my case I chose to structure rather than a class because it can be 
 initialized at compile time.

 But now I thing must be allowed to deploy class in the default data 
 segment. And add the possibility of creating a object of class at 
 compile time.



 If you want to use full blown OOP, class is your choise. There are 
 static constructors for static initialization.



 There does not need a static initialization of static members of the 
 class. There must be able to create objects of classes at compile time.




===========
Now what?

How to initiate the procedure for adding this feature?



 Dec 17 2008



prev sibling  parent reply Kagamin <spam here.lot>  writes:


Weed Wrote:


 There does not need a static initialization of static members of the 
 class. There must be able to create objects of classes at compile time.



Well, these objects should be placed in some static variables, right? Static
variables are initialized with static constructors. Global variables are static
members of module, wich is similar to class and also has static constructor.



 Dec 18 2008



  parent reply Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 There does not need a static initialization of static members of the 
 class. There must be able to create objects of classes at compile time.



 Well, these objects should be placed in some static variables,
 right?



Yes


 Static variables are initialized with static constructors.



Yes, static variables of class are initialized with static constructor 
of class.


 Global variables are static members of module, wich is similar to
 class and also has static constructor.



So what?



 Dec 18 2008



  parent reply Kagamin <spam here.lot>  writes:


Weed Wrote:


 Global variables are static members of module, wich is similar to
 class and also has static constructor.



 So what?



So your problem is solved.



 Dec 18 2008



 next sibling parent  Kagamin <spam here.lot>  writes:


Well, the wish to place an object at specific location is not a problem, it's a
wish.



 Dec 18 2008



prev sibling  parent reply Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 Global variables are static members of module, wich is similar to
 class and also has static constructor.






 So your problem is solved.



If everything was so simple! :)

Once again: the static constructor of class NOT constructs an object. He 
just fills the static variables of class. These variables are common to 
all objects of class.



 Dec 18 2008



 next sibling parent  Weed <resume755 mail.ru>  writes:


Weed пишет:

 Kagamin пишет:

 Weed Wrote:


 Global variables are static members of module, wich is similar to
 class and also has static constructor.






 So your problem is solved.



 If everything was so simple! :)
 
 Once again: the static constructor of class NOT constructs an object. He 
 just fills the static variables of class. These variables are common to 
 all objects of class.



*It* just fills the static variables of class. These variables are 
common to all objects of class.

sorry:)



 Dec 18 2008



prev sibling  parent reply Kagamin <spam here.lot>  writes:


Weed Wrote:


 Kagamin пишет:

 Weed Wrote:
 

 Global variables are static members of module, wich is similar to
 class and also has static constructor.






 So your problem is solved.



 If everything was so simple! :)
 
 Once again: the static constructor of class NOT constructs an object.



Static constructor can execute any valid D statements including construction of
objects.
This works:
---
import std.stdio;

class Matrix
{
	int i;

	this(int j)
	{
		i=j;
	}
}

Matrix m;

static this()
{
	m=new Matrix(7);
}

void main()
{
    writeln(m.i);
}
---



 Dec 18 2008



 next sibling parent reply Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 Kagamin пишет:

 Weed Wrote:


 Global variables are static members of module, wich is similar to
 class and also has static constructor.










 Once again: the static constructor of class NOT constructs an object.



 Static constructor can execute any valid D statements including construction
of objects.



The static constructor does not take *this*. Therefore, it can not 
create instance of object. In your case it initiates the external variable.



 This works:
 ---
 import std.stdio;
 
 class Matrix
 {
 	int i;
 
 	this(int j)
 	{
 		i=j;
 	}
 }
 
 Matrix m;
 
 static this()
 {
 	m=new Matrix(7);
 }
 
 void main()
 {
     writeln(m.i);
 }
 ---






 Dec 18 2008



  parent  Kagamin <spam here.lot>  writes:


Weed Wrote:


 Therefore, it can not create instance of object.



You have a trouble with terminology here.
In my example m=new Matrix(7); creates an instance of Matrix class.



 Dec 18 2008



prev sibling next sibling parent reply naryl <cyNOSPAM ngs.ru>  writes:


Kagamin Wrote:

 Static constructor can execute any valid D statements including construction
of objects.
 This works:
 ---
 import std.stdio;
 
 class Matrix
 {
 	int i;
 
 	this(int j)
 	{
 		i=j;
 	}
 }
 
 Matrix m;
 
 static this()
 {
 	m=new Matrix(7);
 }
 
 void main()
 {
     writeln(m.i);
 }
 ---



I think the problem with that is that if you have a lot of functions every one
of which needs a static instance of the same class you'll need to maintain a
list of static objects in the static constructor. Weed wants every object to be
declared in the function where it is needed.



 Dec 18 2008



  parent  Kagamin <spam here.lot>  writes:


naryl Wrote:


 Weed wants every object to be declared in the function where it is needed.



Haa?..

void main()
{
  Matrix m=new Matrix(7);
  writeln(m.i);
}



 Dec 18 2008



prev sibling  parent reply Derek Parnell <derek psych.ward>  writes:


On Thu, 18 Dec 2008 07:24:34 -0500, Kagamin wrote:


 Static constructor can execute any valid D statements including construction
of objects.



A static constructor (also known as the Module constructor) executes at
program run-time and not at program compile-time. I think Weed wants the
ability to have the compiler build class objects at compile-time such that
when a program first starts running, the objects are already fully formed
in RAM just waiting to be used.

-- 
Derek Parnell
Melbourne, Australia
skype: derek.j.parnell



 Dec 18 2008



 next sibling parent  Weed <resume755 mail.ru>  writes:


Derek Parnell пишет:

 On Thu, 18 Dec 2008 07:24:34 -0500, Kagamin wrote:
 

 Static constructor can execute any valid D statements including construction
of objects.



 A static constructor (also known as the Module constructor) executes at
 program run-time and not at program compile-time. I think Weed wants the
 ability to have the compiler build class objects at compile-time such that
 when a program first starts running, the objects are already fully formed
 in RAM just waiting to be used.
 



It is exactly



 Dec 18 2008



prev sibling  parent reply Kagamin <spam here.lot>  writes:


Derek Parnell Wrote:


 A static constructor (also known as the Module constructor) executes at
 program run-time and not at program compile-time.



So do C++ static object constructors. Though C++ has syntax sugar, which helps
writing declaration and initialization at the same place.



 Dec 19 2008



 next sibling parent reply Sergey Gromov <snake.scaly gmail.com>  writes:


Fri, 19 Dec 2008 04:07:40 -0500, Kagamin wrote:


 Derek Parnell Wrote:
 

 A static constructor (also known as the Module constructor) executes at
 program run-time and not at program compile-time.



 So do C++ static object constructors. Though C++ has syntax sugar,
 which helps writing declaration and initialization at the same place.



C++ static object constructors execute at run time except for trivial
cases.  Essentially C++ provides a sugar for

static Foo var;
static this() { var = new Foo(); }

I wonder if D could do this as well.



 Dec 19 2008



  parent reply Kagamin <spam here.lot>  writes:


Sergey Gromov Wrote:


 C++ static object constructors execute at run time except for trivial
 cases.



Although I think it's not guaranteed to work this way and compiler decides when
to execute constructor. So code should be ready for run-time evaluation. And as
code evolves those constructors can switch back and forth between ct and rt
evaluation.

ps I know a C++ programmer, he wanted to control manually, in what order static
object constructors are called :)



 Dec 21 2008



  parent  Sergey Gromov <snake.scaly gmail.com>  writes:


Sun, 21 Dec 2008 12:04:42 -0500, Kagamin wrote:


 Sergey Gromov Wrote:
 

 C++ static object constructors execute at run time except for trivial
 cases.



 Although I think it's not guaranteed to work this way and compiler
 decides when to execute constructor. So code should be ready for
 run-time evaluation. And as code evolves those constructors can
 switch back and forth between ct and rt evaluation. 
 
 ps I know a C++ programmer, he wanted to control manually, in what
 order static object constructors are called :)



Actually, static constructors are *guaranteed* to run at run time,
before main().  Compiler *may* optimize them out and convert into
initialized DATA if there are no side effects, that is, if optimized
program works exactly as if all static ctors were executed at run time.

C++ guarantees that static ctors are executed in order they appear in a
module.  There is no guarantee about the order in which different
modules are initialized though.



 Dec 22 2008



prev sibling  parent reply Derek Parnell <derek psych.ward>  writes:


On Fri, 19 Dec 2008 04:07:40 -0500, Kagamin wrote:


 Derek Parnell Wrote:
 

 A static constructor (also known as the Module constructor) executes at
 program run-time and not at program compile-time.



 So do C++ static object constructors. Though C++ has syntax sugar, which helps
writing declaration and initialization at the same place.



That's nice I suppose, but I don't think that this is what Weed is talking
about. I think he wants to have some objects constructed at compile-time. 

-- 
Derek Parnell
Melbourne, Australia
skype: derek.j.parnell



 Dec 19 2008



  parent reply Kagamin <spam here.lot>  writes:


Derek Parnell Wrote:


 I think he wants to have some objects constructed at compile-time. 



Sure he wants. From my point of view, this technique is supposed to be a means
to solve some problem rather than problem itself. But this problem was not put.



 Dec 21 2008



 next sibling parent reply Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Derek Parnell Wrote:
 

 I think he wants to have some objects constructed at compile-time. 



 Sure he wants. From my point of view, this technique is supposed to be a means
to solve some problem rather than problem itself. But this problem was not put.



please read it thread:
http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=80945



 Dec 21 2008



  parent reply Kagamin <spam here.lot>  writes:


Weed Wrote:


 Sure he wants. From my point of view, this technique is supposed to be a means
to solve some problem rather than problem itself. But this problem was not put.



 please read it thread:
 http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=80945



The problem of matrix of arbitrary size is solved by size-agnostic base class
whose interface is very similar to that of dynamic matrix.



 Dec 21 2008



  parent reply Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 Sure he wants. From my point of view, this technique is supposed to be a means
to solve some problem rather than problem itself. But this problem was not put.



 http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=80945



 The problem of matrix of arbitrary size is solved by size-agnostic base class
whose interface is very similar to that of dynamic matrix.



If 2 predetermined matrix certain size multiplied, the produced matrix 
must be a certain size rather than dynamic.



 Dec 21 2008



  parent reply Weed <resume755 mail.ru>  writes:


Weed пишет:

 Kagamin пишет:

 Weed Wrote:


 Sure he wants. From my point of view, this technique is supposed to 
 be a means to solve some problem rather than problem itself. But 
 this problem was not put.



 http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmar
.D&article_id=80945 



 The problem of matrix of arbitrary size is solved by size-agnostic 
 base class whose interface is very similar to that of dynamic matrix.



 If 2 predetermined matrix certain size multiplied, the produced matrix 
 must be a certain size rather than dynamic.



...and a matrix of static size in the same used in other objects - 
matrix functional mixed into this objects by mixin.

that is, suppose that after some action should get a matrix matrix3x1

You can not assign it to "pixel" struct, you will receive matrix3x1 and 
make copy of "pixel".



 Dec 21 2008



  parent reply Kagamin <spam here.lot>  writes:


Weed Wrote:


 that is, suppose that after some action should get a matrix matrix3x1



Well... if you want to template every piece of your code, this can cause
disaster, so I think, this is not very good design. For example, multiplication
method will be duplicated N*N*N times for all possible matrix size
combinations. I'd prefer run-time checks, though templates can be used for sure.



 Dec 22 2008



  parent reply Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 that is, suppose that after some action should get a matrix matrix3x1



 Well... if you want to template every piece of your code, this can
 cause disaster, so I think, this is not very good design. For
 example, multiplication method will be duplicated N*N*N times for all
 possible matrix size combinations.



Only for really used combinations (i am using "duck typing" inside 
templates).

In any case, unused functions in the resulting file is not included.


 I'd prefer run-time checks, though
 templates can be used for sure.



This problem would help solve the availability of inheritance for 
structs or compile-time creation of class instances.

But now the compiler can identify duplicate parts of the code, working 
with the same types



 Dec 22 2008



 next sibling parent  Kagamin <spam here.lot>  writes:


Weed Wrote:


 I'd prefer run-time checks, though
 templates can be used for sure.



 This problem would help solve the availability of inheritance for 
 structs or compile-time creation of class instances.



I see no way, how it can help.



 Dec 23 2008



prev sibling  parent reply Kagamin <spam here.lot>  writes:


Weed Wrote:


 I'd prefer run-time checks, though
 templates can be used for sure.



 This problem would help solve the availability of inheritance for 
 structs or compile-time creation of class instances.



And I see no problem. Absence of compile-time object creation doesn't prevent
you from using templates.



 Dec 23 2008



  parent reply Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 I'd prefer run-time checks, though
 templates can be used for sure.



 structs or compile-time creation of class instances.



 And I see no problem. Absence of compile-time object creation doesn't prevent
you from using templates.



The problem is not in use templates.

Templates are implementing some of the functionality of 2 types of 
structures matrices (normal and dynamic). But the structures do not 
inherit, then to add functionality matrix to other entities ( "pixel", 
"image" etc) sites will have their list in a template return type.

For example:
http://www.dsource.org/projects/openmeshd/browser/trunk/LinAlg/linalg/MatrixT.d

see template MultReturnType(ArgT)

It contain list of all types (MatrixT and VectorT) for return. Will it 
add types of "image" and "pixel" and still others if needed. This is as 
good as manually implement a new object model.

It is not necessary to suggest to wrap up "pixel" in a class - then it 
too cannot be initialized in a compile time.



 Dec 23 2008



 next sibling parent reply Kagamin <spam here.lot>  writes:


Weed Wrote:


 The problem is not in use templates.
 
 Templates are implementing some of the functionality of 2 types of 
 structures matrices (normal and dynamic). But the structures do not 
 inherit, then to add functionality matrix to other entities ( "pixel", 
 "image" etc) sites will have their list in a template return type.



If structs don't suit you, don't use them. Classes are better suited for OOP as
I said long ago and continue repeating it over and over.


 It contain list of all types (MatrixT and VectorT) for return. Will it 
 add types of "image" and "pixel" and still others if needed. This is as 
 good as manually implement a new object model.



I'm sure any properly formalized problem is solvable. All you need is proper
formalization and some design work.


 It is not necessary to suggest to wrap up "pixel" in a class - then it 
 too cannot be initialized in a compile time.



Sure it can't. Does it cause that big problems?



 Dec 23 2008



  parent reply Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 The problem is not in use templates.

 Templates are implementing some of the functionality of 2 types of 
 structures matrices (normal and dynamic). But the structures do not 
 inherit, then to add functionality matrix to other entities ( "pixel", 
 "image" etc) sites will have their list in a template return type.



 If structs don't suit you, don't use them. Classes are better suited for OOP
as I said long ago and continue repeating it over and over.
 

 It contain list of all types (MatrixT and VectorT) for return. Will it 
 add types of "image" and "pixel" and still others if needed. This is as 
 good as manually implement a new object model.



 I'm sure any properly formalized problem is solvable. All you need is proper
formalization and some design work.
 

 It is not necessary to suggest to wrap up "pixel" in a class - then it 
 too cannot be initialized in a compile time.



 Sure it can't. Does it cause that big problems?



Sometimes it is the only way to avoid a large number of global ad



 Dec 23 2008



  parent reply Kagamin <spam here.lot>  writes:


Weed Wrote:


 It is not necessary to suggest to wrap up "pixel" in a class - then it 
 too cannot be initialized in a compile time.



 Sure it can't. Does it cause that big problems?



 Sometimes it is the only way to avoid a large number of global ad



In D module variables can be protected by access modifiers and become
module-local.



 Dec 24 2008



  parent reply Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 It is not necessary to suggest to wrap up "pixel" in a class - then it 
 too cannot be initialized in a compile time.









 In D module variables can be protected by access modifiers and become
module-local.



Module full of mathematics turns into horror quite quickly. I have 
checked this:)



 Dec 24 2008



  parent reply Kagamin <spam here.lot>  writes:


Weed Wrote:


 too cannot be initialized in a compile time.









 In D module variables can be protected by access modifiers and become
module-local.



 Module full of mathematics turns into horror quite quickly. I have 
 checked this:)



If you have troubles with understanding big modules, you can split them into
smaller modules, which will be easier to understand for sure.



 Dec 24 2008



  parent reply Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 too cannot be initialized in a compile time.












 checked this:)



 If you have troubles with understanding big modules, you can split them into
smaller modules, which will be easier to understand for sure.




If you do not want to initialize repeatedly matrix inside the sub, which 
often cause each other, must be static matrices or declared as global 
(in relation to these procedures). You agree with that?

Do you propose through mixin divide the code into parts?

You do not think that it is better to add to language that would give 
100% to use the opportunity of calculations at compile time. This 
greatly simplify the code and perfectly and logically fit into the language.



 Dec 24 2008



  parent reply Kagamin <spam here.lot>  writes:


Weed Wrote:


 If you do not want to initialize repeatedly matrix inside the sub, which 
 often cause each other, must be static matrices or declared as global 
 (in relation to these procedures). You agree with that?



What's problem? If you want static or global variables, you have them in D.


 Do you propose through mixin divide the code into parts?



Well, why mixin? Just create different modules and place code according to its
purpose to these modules.


 You do not think that it is better to add to language that would give 
 100% to use the opportunity of calculations at compile time. This 
 greatly simplify the code and perfectly and logically fit into the language.



Compile-time evaluation is just an optimization technique, which may or may not
be applied without any change to source code, so it doesn't affect source code
in any way, it just can't. In C++ you can't tell whether the code executes at
compile time, as as of standard, it's completely up to the compiler to optimize
code generation.



 Dec 25 2008



 next sibling parent  Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 If you do not want to initialize repeatedly matrix inside the sub, which 
 often cause each other, must be static matrices or declared as global 
 (in relation to these procedures). You agree with that?



 What's problem? If you want static or global variables, you have them in D.
 

 Do you propose through mixin divide the code into parts?



 Well, why mixin? Just create different modules and place code according to its
purpose to these modules.
 

 You do not think that it is better to add to language that would give 
 100% to use the opportunity of calculations at compile time. This 
 greatly simplify the code and perfectly and logically fit into the language.



 Compile-time evaluation is just an optimization technique, which may or may
not be applied without any change to source code, so it doesn't affect source
code in any way, it just can't. In C++ you can't tell whether the code executes
at compile time, as as of standard, it's completely up to the compiler to
optimize code generation.



Yeah, right.

I propose that it be expanded to optimize the static arrays and classes.



 Dec 25 2008



prev sibling  parent  Weed <resume755 mail.ru>  writes:


Kagamin пишет:

 Weed Wrote:
 

 If you do not want to initialize repeatedly matrix inside the sub, which 
 often cause each other, must be static matrices or declared as global 
 (in relation to these procedures). You agree with that?



 What's problem? If you want static or global variables, you have them in D.
 

 Do you propose through mixin divide the code into parts?



 Well, why mixin? Just create different modules and place code according to its
purpose to these modules.
 

 You do not think that it is better to add to language that would give 
 100% to use the opportunity of calculations at compile time. This 
 greatly simplify the code and perfectly and logically fit into the language.



 Compile-time evaluation is just an optimization technique, which may or may
not be applied without any change to source code,



Incidentally, this is incorrect.

In the event that it is impossible to calculate the static expression
compiler immediately gives an error rather than moves calculation to
run-time.



 Dec 25 2008



prev sibling  parent  Weed <resume755 mail.ru>  writes:


Weed пишет:

 Kagamin пишет:

 Weed Wrote:


 I'd prefer run-time checks, though
 templates can be used for sure.



 structs or compile-time creation of class instances.



 And I see no problem. Absence of compile-time object creation doesn't 
 prevent you from using templates.



 The problem is not in use templates.
 
 Templates are implementing some of the functionality of 2 types of 
 structures matrices (normal and dynamic). But the structures do not 
 inherit, then to add functionality matrix to other entities ( "pixel", 
 "image" etc) sites will have their list in a template return type.
 
 For example:
 http://www.dsource.org/projects/openmeshd/browser/trunk/Lin
lg/linalg/MatrixT.d 
 
 
 see template MultReturnType(ArgT)
 
 It contain list of all types (MatrixT and VectorT) for return. Will it 
 add types of "image" and "pixel" and still others if needed. This is as 
 good as manually implement a new object model.
 
 It is not necessary to suggest to wrap up "pixel" in a class - then it 
 too cannot be initialized in a compile time.



In fact, the minimum number of matrices 3:
dynamic
fixed-size
fixed-size static

The last 2 are different way of storing components - "fixed-size static" 
  has dynamic array (because compile-time assignment is now does not 
assign anything to static array) and "fixed-size" it with a static array 
with size calculated in the template.


I will be happy if someone tells a mistake in the design of my idea :)



 Dec 24 2008



prev sibling  parent reply Kagamin <spam here.lot>  writes:


Denis Koroskin Wrote:


 class Widget
 {
     WidgetFactory* factory = &defaultFactory;
 }
 
 void main()
 {
     Widget w = new Widget();
     writefln(w.factory.someParameterValue); // prints 14
 }



You initialize member field here. It's usually done in instance constructor.

class Widget
{
    WidgetFactory factory;
    this(){ factory = defaultFactory; }
}



 Dec 22 2008



  parent reply Denis Koroskin <2korden gmail.com>  writes:


Kagamin Wrote:


 Denis Koroskin Wrote:
 

 class Widget
 {
     WidgetFactory* factory = &defaultFactory;
 }
 
 void main()
 {
     Widget w = new Widget();
     writefln(w.factory.someParameterValue); // prints 14
 }



 You initialize member field here. It's usually done in instance constructor.
 
 class Widget
 {
     WidgetFactory factory;
     this(){ factory = defaultFactory; }
 }



I don't agree with you. If so, then why we have the following syntax allowed:

class Foo
{
    int i = 42;
}

if we could just use

class Foo
{
    this()
    {
        i = 42;
    }
}

?

Imagine you have lots of ctors (with different arguments), should you put i =
42; into every one? Or move it into some initialize() method? Don't you think
it is too verbose?



 Dec 22 2008



  parent  Kagamin <spam here.lot>  writes:


Denis Koroskin Wrote:


 I don't agree with you. If so, then why we have the following syntax allowed:
 
 class Foo
 {
     int i = 42;
 }



It fits well into .init feature. If you want to split constructor, some subtle
bugs can arise. For example one programmer stumbled into such bug in Java: base
class constructor was called, it called virtual method, overriden in derived
class, this method assigned an object to a field, then base class constructor
returned and derived field initializers were called and they assigned null to
that field, so object ended up with null in the field.



 Dec 23 2008



prev sibling  parent  "Denis Koroskin" <2korden gmail.com>  writes:


On Sun, 21 Dec 2008 19:34:52 +0300, Kagamin <spam here.lot> wrote:


 Derek Parnell Wrote:


 I think he wants to have some objects constructed at compile-time.



 Sure he wants. From my point of view, this technique is supposed to be a  
 means to solve some problem rather than problem itself. But this problem  
 was not put.



Ok, here is a problem out of my head:

Let's say we have a GUI application with Widgets and WidgetFactories. Each
widget is initialized with a *valid* pointer to some WidgetFactory (a dummy
one, perhaps) to avoid "if (factory !is null) factory.doSomething();" checks
(for example). Our first try:

import std.stdio;

struct WidgetFactory
{
    int someParameterValue = 42;
}

WidgetFactory defaultFactory = { 14 }; 

class Widget
{
    WidgetFactory* factory = &defaultFactory;
}

void main()
{
    Widget w = new Widget();
    writefln(w.factory.someParameterValue); // prints 14
}

It works, because memory for global structs is reserved at compile time and
pointer to it is also a known compile-time expression. Let's go further and see
if we can replace a struct with a class instance:

WidgetFactory defaultFactory;

class Widget
{
    WidgetFactory factory = defaultFactory;
}

This code compiles but doesn't work as we need. Another try:

WidgetFactory defaultFactory;

static this()
{
    defaultFactory = new StubFactory();
}

class Widget
{
    WidgetFactory* factory = &defaultFactory;
}

Works as we need but we now have to dereference a pointer twice.

A better solution would be to have the following:

WidgetFactory defaultFactory = new StubFactory();

class Widget
{
    WidgetFactory factory = defaultFactory;
}

A memory for 'defaultFactory' is reserved at compile-time whereas a ctor is ran
at run-time (similar to "static this" construct).
In fact, allowing reference type to created at compile time would eliminate
most of the needs for static this. The following construct:

Foo foo;
static this()
{
    foo = new Foo();
}

could be replaced with

Foo foo = new Foo();

which behaves just the same but is shorter, nicier, easier to write and read
(undestand).



 Dec 21 2008



prev sibling  parent reply Janderson <ask me.com>  writes:


Weed wrote:

 I should explain why it's important for me:
 
 For example, I am making a matrix object(s)
 
 It should be:
 - any size
 - with ability of making matrix instance of a given size in compile time.
 - ability of creating matrix instance in runtime.
 
 I have decided to make it struct because I need to create matrix
 object in compile time. in real program I'll need matricies of
 variable size and 3х1, 3х3, 6х6, 3х6 sizes (and may be other).
 
 I want to make matrix template and insert in it with mixin operator
 several structures of different sizes (and this structs are not store 
 his dimensions in each instance, of course: variables width and height 
 declared as invariant). By doing this I'll get several different 
 structures  (matrix_dynamic, matrix3x3, matrix6x6 etc)
 
 question is how those matricies can interoperate? They does not have
 common parent (structures does not have inheritance) , so I can't
 make common function for matricies of different sizes opAdd for
 example, and have to do functions for all types of matricies.
 
 How should I implement such a class In D properly?     
 It possible in C++, but I like some of the language D



The classical approach is to have "helper" template functions. 
Essentially:

void doOpearation(mymatrix)(...)
{

}


Note this is compiletime polymorphisms.

Now if you want to add runtime polymorphism it is impossible to get away 
from a cost.  You can use a wrapper class like so:

interface CommonMatrix
{
	operation()...
}

class PolymorphicMatrix(mymatrix) : CommonMatrix
{
	operation()...
}

You'll probably find though that PolymorphicMartix should be some higher 
level concept, like car, or entity.

The great thing about these techniques is that they give a whole load 
more power then just using inheritance alone because you can essentially 
attach many different behaviors to that struct.

I hope that was helpful.

-Joel



 Dec 17 2008



 next sibling parent reply Weed <resume755 mail.ru>  writes:


Janderson пишет:

 Weed wrote:

 I should explain why it's important for me:

 For example, I am making a matrix object(s)

 It should be:
 - any size
 - with ability of making matrix instance of a given size in compile time.
 - ability of creating matrix instance in runtime.

 I have decided to make it struct because I need to create matrix
 object in compile time. in real program I'll need matricies of
 variable size and 3х1, 3х3, 6х6, 3х6 sizes (and may be other).

 I want to make matrix template and insert in it with mixin operator
 several structures of different sizes (and this structs are not store 
 his dimensions in each instance, of course: variables width and height 
 declared as invariant). By doing this I'll get several different 
 structures  (matrix_dynamic, matrix3x3, matrix6x6 etc)

 question is how those matricies can interoperate? They does not have
 common parent (structures does not have inheritance) , so I can't
 make common function for matricies of different sizes opAdd for
 example, and have to do functions for all types of matricies.

 How should I implement such a class In D properly?     It possible in 
 C++, but I like some of the language D



 The classical approach is to have "helper" template functions. Essentially:
 
 void doOpearation(mymatrix)(...)
 {
 
 }



If I create struct MatrixStruct for compile-time matrix and class 
MatrixClass for all other I will not be able to create a function of 
interaction between these objects through the templates because some of 
them will be announced before the other and it will not be able to get 
another type of object in a template.

(I do not know, understand this long phrase on my strange English or 
not? : ))



 
 
 Note this is compiletime polymorphisms.
 
 Now if you want to add runtime polymorphism it is impossible to get away 
 from a cost.  You can use a wrapper class like so:
 
 interface CommonMatrix
 {
     operation()...
 }



	
Also, interfaces can not be used with the structs



 
 class PolymorphicMatrix(mymatrix) : CommonMatrix
 {
     operation()...
 }
 
 You'll probably find though that PolymorphicMartix should be some higher 
 level concept, like car, or entity.
 
 The great thing about these techniques is that they give a whole load 
 more power then just using inheritance alone because you can essentially 
 attach many different behaviors to that struct.
 
 I hope that was helpful.
 
 -Joel






 Dec 17 2008



 next sibling parent reply Christopher Wright <dhasenan gmail.com>  writes:


Weed wrote:

 If I create struct MatrixStruct for compile-time matrix and class 
 MatrixClass for all other I will not be able to create a function of 
 interaction between these objects through the templates because some of 
 them will be announced before the other and it will not be able to get 
 another type of object in a template.
 
 (I do not know, understand this long phrase on my strange English or 
 not? : ))



What operations do you need at compile time and what operations do you 
need at runtime?



 Dec 17 2008



  parent reply Weed <resume755 mail.ru>  writes:


Christopher Wright пишет:

 Weed wrote:

 If I create struct MatrixStruct for compile-time matrix and class 
 MatrixClass for all other I will not be able to create a function of 
 interaction between these objects through the templates because some 
 of them will be announced before the other and it will not be able to 
 get another type of object in a template.

 (I do not know, understand this long phrase on my strange English or 
 not? : ))



 What operations do you need at compile time and what operations do you 
 need at runtime?



Compile-time creation an object of class or (most likely wrong) struct 
inheritance.

I have prepared a distinct feature request and send it later



 Dec 17 2008



 next sibling parent  Weed <resume755 mail.ru>  writes:


Weed пишет:

 Christopher Wright пишет:

 Weed wrote:

 If I create struct MatrixStruct for compile-time matrix and class 
 MatrixClass for all other I will not be able to create a function of 
 interaction between these objects through the templates because some 
 of them will be announced before the other and it will not be able to 
 get another type of object in a template.

 (I do not know, understand this long phrase on my strange English or 
 not? : ))



 What operations do you need at compile time and what operations do you 
 need at runtime?



 Compile-time creation an object of class or (most likely wrong) struct 
 inheritance.
 
 I have prepared a distinct feature request and send it later



You can read this in the digitalmars.D, topic:
Feature request: Deploying a class instance in the default data segment



 Dec 17 2008



prev sibling  parent reply Christopher Wright <dhasenan gmail.com>  writes:


Weed wrote:

 Compile-time creation an object of class or (most likely wrong) struct 
 inheritance.
 
 I have prepared a distinct feature request and send it later



You aren't providing a use case, though. Why not show an example (actual 
code) of what you would do if you had this ability?



 Dec 18 2008



  parent reply Sergey Gromov <snake.scaly gmail.com>  writes:


Thu, 18 Dec 2008 18:36:07 -0500, Christopher Wright wrote:


 Weed wrote:

 Compile-time creation an object of class or (most likely wrong) struct 
 inheritance.
 
 I have prepared a distinct feature request and send it later



 You aren't providing a use case, though. Why not show an example (actual 
 code) of what you would do if you had this ability?



static invariant Identity = new Matrix([[1,0,0], [0,1,0], [0,0,1]]);



 Dec 19 2008



  parent reply Christopher Wright <dhasenan gmail.com>  writes:


Sergey Gromov wrote:

 Thu, 18 Dec 2008 18:36:07 -0500, Christopher Wright wrote:
 

 Weed wrote:

 Compile-time creation an object of class or (most likely wrong) struct 
 inheritance.

 I have prepared a distinct feature request and send it later



 code) of what you would do if you had this ability?



 static invariant Identity = new Matrix([[1,0,0], [0,1,0], [0,0,1]]);



Okay, do you want to access that matrix in a template? Is there a reason 
it can't be a struct?



 Dec 20 2008



  parent  Christopher Wright <dhasenan gmail.com>  writes:


Denis Koroskin wrote:

 On Sat, 20 Dec 2008 16:46:44 +0300, Christopher Wright 
 <dhasenan gmail.com> wrote:
 

 Sergey Gromov wrote:

 Thu, 18 Dec 2008 18:36:07 -0500, Christopher Wright wrote:


 Weed wrote:

 Compile-time creation an object of class or (most likely wrong) 
 struct inheritance.

 I have prepared a distinct feature request and send it later



 (actual code) of what you would do if you had this ability?






 Okay, do you want to access that matrix in a template? Is there a 
 reason it can't be a struct?



 Let's say, there is an IMatrix interface and its implementations, such 
 as SparseMatrix, RowMajor/ColumnMajorMatrix etc.
 
 class IdentityMatrix : IMatrix
 {
     public float at(int row, int col) { return (row == col) ? 1 : 0; }
 }



Score! We finally have a use case! I thought there would be a reasonable 
use case, but I couldn't come up with one off the top of my head.

The workaround would be to use a struct at compile time and convert to 
an appropriate class when necessary. This is a rather ugly workaround; 
it takes a fair bit of time at runtime and increases executable sizes (I 
don't think you could do a sparse matrix at compile time, for instance 
-- you would need dynamic allocation for that).



 Dec 20 2008



prev sibling  parent reply Janderson <ask me.com>  writes:


Weed wrote:

 Janderson пишет:

 Weed wrote:

 I should explain why it's important for me:

 For example, I am making a matrix object(s)

 It should be:
 - any size
 - with ability of making matrix instance of a given size in compile 
 time.
 - ability of creating matrix instance in runtime.

 I have decided to make it struct because I need to create matrix
 object in compile time. in real program I'll need matricies of
 variable size and 3х1, 3х3, 6х6, 3х6 sizes (and may be other).

 I want to make matrix template and insert in it with mixin operator
 several structures of different sizes (and this structs are not store 
 his dimensions in each instance, of course: variables width and 
 height declared as invariant). By doing this I'll get several 
 different structures  (matrix_dynamic, matrix3x3, matrix6x6 etc)

 question is how those matricies can interoperate? They does not have
 common parent (structures does not have inheritance) , so I can't
 make common function for matricies of different sizes opAdd for
 example, and have to do functions for all types of matricies.

 How should I implement such a class In D properly?     It possible in 
 C++, but I like some of the language D



 The classical approach is to have "helper" template functions. 
 Essentially:

 void doOpearation(mymatrix)(...)
 {

 }



 If I create struct MatrixStruct for compile-time matrix and class 
 MatrixClass for all other I will not be able to create a function of 
 interaction between these objects through the templates because some of 
 them will be announced before the other and it will not be able to get 
 another type of object in a template.
 
 (I do not know, understand this long phrase on my strange English or 
 not? : ))
 
 

 Note this is compiletime polymorphisms.

 Now if you want to add runtime polymorphism it is impossible to get 
 away from a cost.  You can use a wrapper class like so:

 interface CommonMatrix
 {
     operation()...
 }



     
 Also, interfaces can not be used with the structs




I'm not sure what you mean:

I meant this:

You have your struct:

struct Foo
{

}

Then you have your template wrapper

class DoDynamicPolymorpicStuff(T) : TheInterface
{
	T foo;

	operation()
	{
		foo;
	}
}


Its a reasonably common pattern.


 
 

 class PolymorphicMatrix(mymatrix) : CommonMatrix
 {
     operation()...
 }

 You'll probably find though that PolymorphicMartix should be some 
 higher level concept, like car, or entity.

 The great thing about these techniques is that they give a whole load 
 more power then just using inheritance alone because you can 
 essentially attach many different behaviors to that struct.

 I hope that was helpful.

 -Joel









 Dec 17 2008



  parent  Weed <resume755 mail.ru>  writes:


Janderson пишет:

 Weed wrote:

 Janderson пишет:

 Weed wrote:

 I should explain why it's important for me:

 For example, I am making a matrix object(s)

 It should be:
 - any size
 - with ability of making matrix instance of a given size in compile 
 time.
 - ability of creating matrix instance in runtime.

 I have decided to make it struct because I need to create matrix
 object in compile time. in real program I'll need matricies of
 variable size and 3х1, 3х3, 6х6, 3х6 sizes (and may be other).

 I want to make matrix template and insert in it with mixin operator
 several structures of different sizes (and this structs are not 
 store his dimensions in each instance, of course: variables width 
 and height declared as invariant). By doing this I'll get several 
 different structures  (matrix_dynamic, matrix3x3, matrix6x6 etc)

 question is how those matricies can interoperate? They does not have
 common parent (structures does not have inheritance) , so I can't
 make common function for matricies of different sizes opAdd for
 example, and have to do functions for all types of matricies.

 How should I implement such a class In D properly?     It possible 
 in C++, but I like some of the language D



 The classical approach is to have "helper" template functions. 
 Essentially:

 void doOpearation(mymatrix)(...)
 {

 }



 If I create struct MatrixStruct for compile-time matrix and class 
 MatrixClass for all other I will not be able to create a function of 
 interaction between these objects through the templates because some 
 of them will be announced before the other and it will not be able to 
 get another type of object in a template.

 (I do not know, understand this long phrase on my strange English or 
 not? : ))



 Note this is compiletime polymorphisms.

 Now if you want to add runtime polymorphism it is impossible to get 
 away from a cost.  You can use a wrapper class like so:

 interface CommonMatrix
 {
     operation()...
 }



     Also, interfaces can not be used with the structs



 
 I'm not sure what you mean:
 
 I meant this:
 
 You have your struct:
 
 struct Foo
 {
 
 }
 
 Then you have your template wrapper
 
 class DoDynamicPolymorpicStuff(T) : TheInterface
 {
     T foo;
 
     operation()
     {
         foo;
     }
 }
 
 
 Its a reasonably common pattern.
 



How do you implement matrix data of this class in compile-time in the 
case of matrix is fixed-sized?

Whether you can start immediately after the program began to operate 
this class matrix as if it was created at compile time?


 class PolymorphicMatrix(mymatrix) : CommonMatrix
 {
     operation()...
 }

 You'll probably find though that PolymorphicMartix should be some 
 higher level concept, like car, or entity.

 The great thing about these techniques is that they give a whole load 
 more power then just using inheritance alone because you can 
 essentially attach many different behaviors to that struct.

 I hope that was helpful.

 -Joel












 Dec 17 2008



prev sibling  parent  "Denis Koroskin" <2korden gmail.com>  writes:


On Sat, 20 Dec 2008 16:46:44 +0300, Christopher Wright  
<dhasenan gmail.com> wrote:


 Sergey Gromov wrote:

 Thu, 18 Dec 2008 18:36:07 -0500, Christopher Wright wrote:


 Weed wrote:

 Compile-time creation an object of class or (most likely wrong)  
 struct inheritance.

 I have prepared a distinct feature request and send it later



 (actual code) of what you would do if you had this ability?






 Okay, do you want to access that matrix in a template? Is there a reason  
 it can't be a struct?



Let's say, there is an IMatrix interface and its implementations, such as  
SparseMatrix, RowMajor/ColumnMajorMatrix etc.

class IdentityMatrix : IMatrix
{
     public float at(int row, int col) { return (row == col) ? 1 : 0; }
}



 Dec 20 2008