digitalmars.D - Feature request: Deploying a class instance in the default data segment
- Weed (23/23) Dec 17 2008 Feature request: Deploying a class instance in the default data segment
- Bill Baxter (12/36) Dec 17 2008 This point I don't think is true. DynamicMatrix can implement methods
- Weed (12/58) Dec 17 2008 Yes, or suppose I want to add a class matrix, which is part of an
- Bill Baxter (46/46) Dec 17 2008 MjAwOC8xMi8xOCBXZWVkIDxyZXN1bWU3NTVAbWFpbC5ydT46Cj4gQmlsbCBCYXh0ZXIg0Mnb...
- Weed (56/112) Dec 17 2008 slice
- Weed (19/68) Dec 21 2008 Here other example:
- Kagamin (2/4) Dec 18 2008 Oh, yes, how could I forget about some matrices... :)
- Weed (8/40) Dec 18 2008 In more general terms:
Feature request: Deploying a class instance in the default data segment and creation of a class instance at compile time. In this post I'll try to prove the necessity of this feature. I have found that in D it is impossible to create a polymorphic object (class or struct) which can be created at compile-time. Good specific example of such an object is a matrix class. For some matrices it is good to create and initialize them at compile time, not dynamically at run time. Also for matrices of predefined size it is wrong to duplicate their dimensions (their width and height should be declared invariant and, consequently occupy memory only once) At the same time dynamically created matrices of arbitrary size which can be changed at run time are also needed. For example to make a slice of giant matrix it's more efficient to modify it in-place than to copy it. These matrices have variable width and height. So we have minimum two types of matrices: dynamic and constant sized with ability of compile time initialization. It is necessary to provide interaction between them (for example overload arithmetic operators for them). For this purpose it is necessary for them to be inherited from common parent. So it can not be structures, only classes. But classes can not be created at compile time. So I propose to add possibility of deployment of class instance in the default data segment and creation of class instance at compile time.
Dec 17 2008
On Thu, Dec 18, 2008 at 2:05 PM, Weed <resume755 mail.ru> wrote:Feature request: Deploying a class instance in the default data segment and creation of a class instance at compile time. In this post I'll try to prove the necessity of this feature. I have found that in D it is impossible to create a polymorphic object (class or struct) which can be created at compile-time. Good specific example of such an object is a matrix class. For some matrices it is good to create and initialize them at compile time, not dynamically at run time. Also for matrices of predefined size it is wrong to duplicate their dimensions (their width and height should be declared invariant and, consequently occupy memory only once) At the same time dynamically created matrices of arbitrary size which can be changed at run time are also needed. For example to make a slice of giant matrix it's more efficient to modify it in-place than to copy it. These matrices have variable width and height. So we have minimum two types of matrices: dynamic and constant sized with ability of compile time initialization. It is necessary to provide interaction between them (for example overload arithmetic operators for them). For this purpose it is necessary for them to be inherited from common parent.This point I don't think is true. DynamicMatrix can implement methods like opMult(StaticMatrix M), and vice versa. The only thing I can think of you can't do is make an array of pointers to Matrix, the elements of which might be a DynamicMatrix, or might be StaticMatrix. But even that, if you really feel you need it for some reason, could be done using a struct/class with a union inside. Most cases where you might want to accept either/or can be done with templates.So it can not be structures, only classes. But classes can not be created at compile time. So I propose to add possibility of deployment of class instance in the default data segment and creation of class instance at compile time.This might be a useful feature, but I'm not finding your argument for it quite convincing enough yet. --bb
Dec 17 2008
Bill Baxter пишет:On Thu, Dec 18, 2008 at 2:05 PM, Weed <resume755 mail.ru> wrote:I'm not sure (see below)Feature request: Deploying a class instance in the default data segment and creation of a class instance at compile time. In this post I'll try to prove the necessity of this feature. I have found that in D it is impossible to create a polymorphic object (class or struct) which can be created at compile-time. Good specific example of such an object is a matrix class. For some matrices it is good to create and initialize them at compile time, not dynamically at run time. Also for matrices of predefined size it is wrong to duplicate their dimensions (their width and height should be declared invariant and, consequently occupy memory only once) At the same time dynamically created matrices of arbitrary size which can be changed at run time are also needed. For example to make a slice of giant matrix it's more efficient to modify it in-place than to copy it. These matrices have variable width and height. So we have minimum two types of matrices: dynamic and constant sized with ability of compile time initialization. It is necessary to provide interaction between them (for example overload arithmetic operators for them). For this purpose it is necessary for them to be inherited from common parent.This point I don't think is true. DynamicMatrix can implement methods like opMult(StaticMatrix M), and vice versa.The only thing I can think of you can't do is make an array of pointers to Matrix, the elements of which might be a DynamicMatrix, or might be StaticMatrix.Yes, or suppose I want to add a class matrix, which is part of an existing large matrix (which is a kind of frame).But even that, if you really feel you need it for some reason, could be done using a struct/class with a union inside. Most cases where you might want to accept either/or can be done with templates.I think this is impossible. If I create struct for compile-time matrix and class for all other I will not be able to create a methods for 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. tell if the phrase is unclear)Yes, perhaps matrix is not good exampleSo it can not be structures, only classes. But classes can not be created at compile time. So I propose to add possibility of deployment of class instance in the default data segment and creation of class instance at compile time.This might be a useful feature, but I'm not finding your argument for it quite convincing enough yet.
Dec 17 2008
MjAwOC8xMi8xOCBXZWVkIDxyZXN1bWU3NTVAbWFpbC5ydT46Cj4gQmlsbCBCYXh0ZXIg0MnbxdQ6 Cj4+Cj4+IE9uIFRodSwgRGVjIDE4LCAyMDA4IGF0IDI6MDUgUE0sIFdlZWQgPHJlc3VtZTc1NUBt YWlsLnJ1PiB3cm90ZToKPj4+Cj4+PiBGZWF0dXJlIHJlcXVlc3Q6IERlcGxveWluZyBhIGNsYXNz IGluc3RhbmNlIGluIHRoZSBkZWZhdWx0IGRhdGEgc2VnbWVudAo+Pj4gYW5kCj4+PiBjcmVhdGlv biBvZiBhIGNsYXNzIGluc3RhbmNlIGF0IGNvbXBpbGUgdGltZS4KPj4+Cj4+PiBJbiB0aGlzIHBv c3QgSSdsbCB0cnkgdG8gcHJvdmUgdGhlIG5lY2Vzc2l0eSBvZiB0aGlzIGZlYXR1cmUuCj4+Pgo+ Pj4gSSBoYXZlIGZvdW5kIHRoYXQgaW4gRCBpdCBpcyBpbXBvc3NpYmxlIHRvIGNyZWF0ZSBhIHBv bHltb3JwaGljIG9iamVjdAo+Pj4gKGNsYXNzIG9yIHN0cnVjdCkgd2hpY2ggY2FuIGJlIGNyZWF0 ZWQgYXQgY29tcGlsZS10aW1lLgo+Pj4KPj4+IEdvb2Qgc3BlY2lmaWMgZXhhbXBsZSBvZiBzdWNo IGFuIG9iamVjdCBpcyBhIG1hdHJpeCBjbGFzcy4KPj4+Cj4+PiBGb3Igc29tZSBtYXRyaWNlcyBp dCBpcyBnb29kIHRvIGNyZWF0ZSBhbmQgaW5pdGlhbGl6ZSB0aGVtIGF0IGNvbXBpbGUKPj4+IHRp bWUsIG5vdCBkeW5hbWljYWxseSBhdCBydW4gdGltZS4KPj4+Cj4+PiBBbHNvIGZvciBtYXRyaWNl cyBvZiBwcmVkZWZpbmVkIHNpemUgaXQgaXMgd3JvbmcgdG8gZHVwbGljYXRlIHRoZWlyCj4+PiBk aW1lbnNpb25zICh0aGVpciB3aWR0aCBhbmQgaGVpZ2h0IHNob3VsZCBiZSBkZWNsYXJlZCBpbnZh cmlhbnQgYW5kLAo+Pj4gY29uc2VxdWVudGx5IG9jY3VweSBtZW1vcnkgb25seSBvbmNlKQo+Pj4K Pj4+IEF0IHRoZSBzYW1lIHRpbWUgZHluYW1pY2FsbHkgY3JlYXRlZCBtYXRyaWNlcyBvZiBhcmJp dHJhcnkgc2l6ZSB3aGljaAo+Pj4gY2FuIGJlIGNoYW5nZWQgYXQgcnVuIHRpbWUgYXJlIGFsc28g bmVlZGVkLiBGb3IgZXhhbXBsZSB0byBtYWtlIGEgc2xpY2UKPj4+IG9mCj4+PiBnaWFudCBtYXRy aXggaXQncyBtb3JlIGVmZmljaWVudCB0byBtb2RpZnkgaXQgaW4tcGxhY2UgdGhhbiB0byBjb3B5 IGl0Lgo+Pj4gVGhlc2UgbWF0cmljZXMgaGF2ZSB2YXJpYWJsZSB3aWR0aCBhbmQgaGVpZ2h0Lgo+ Pj4KPj4+IFNvIHdlIGhhdmUgbWluaW11bSB0d28gdHlwZXMgb2YgbWF0cmljZXM6IGR5bmFtaWMg YW5kIGNvbnN0YW50IHNpemVkIHdpdGgKPj4+IGFiaWxpdHkgb2YgY29tcGlsZSB0aW1lIGluaXRp YWxpemF0aW9uLiBJdCBpcyBuZWNlc3NhcnkgdG8gcHJvdmlkZQo+Pj4gaW50ZXJhY3Rpb24gYmV0 d2VlbiB0aGVtIChmb3IgZXhhbXBsZSBvdmVybG9hZCBhcml0aG1ldGljIG9wZXJhdG9ycwo+Pj4g Zm9yIHRoZW0pLiBGb3IgdGhpcyBwdXJwb3NlIGl0IGlzIG5lY2Vzc2FyeSBmb3IgdGhlbSB0byBi ZSBpbmhlcml0ZWQKPj4+IGZyb20gY29tbW9uIHBhcmVudC4KPj4KPj4gVGhpcyBwb2ludCBJIGRv bid0IHRoaW5rIGlzIHRydWUuICBEeW5hbWljTWF0cml4IGNhbiBpbXBsZW1lbnQgbWV0aG9kcwo+ PiBsaWtlIG9wTXVsdChTdGF0aWNNYXRyaXggTSksIGFuZCB2aWNlIHZlcnNhLgoKCj4gSSB0aGlu ayB0aGlzIGlzIGltcG9zc2libGUuIElmIEkgY3JlYXRlIHN0cnVjdCBmb3IgY29tcGlsZS10aW1l IG1hdHJpeCBhbmQKPiBjbGFzcyBmb3IgYWxsIG90aGVyIEkgd2lsbCBub3QgYmUgYWJsZSB0byBj cmVhdGUgYSBtZXRob2RzIGZvciBpbnRlcmFjdGlvbgo+IGJldHdlZW4gdGhlc2Ugb2JqZWN0cyB0 aHJvdWdoIHRoZSB0ZW1wbGF0ZXMgYmVjYXVzZSBzb21lIG9mIHRoZW0gd2lsbCBiZQo+IGFubm91 bmNlZCBiZWZvcmUgdGhlIG90aGVyIGFuZCBpdCB3aWxsIG5vdCBiZSBhYmxlIHRvIGdldCBhbm90 aGVyIHR5cGUgb2YKPiBvYmplY3QgaW4gYSB0ZW1wbGF0ZS4KCllvdSBtZWFuIHRoZXJlIHdpbGwg YmUgdGhpcyBjaXJjdWxhciBkZXBlbmRlbmN5PwoKICAgc3RydWN0IER5bmFtaWNNYXRyaXggewog ICAgICAgRHluYW1pY01hdHJpeCBvcE11bChTdGF0aWNNYXRyaXggbSkgey4uLn0KICAgICAgIC4u LgogICB9CgogICBzdHJ1Y3QgU3RhdGljTWF0cml4IHsKICAgICAgICBEeW5hbWljTWF0cml4IG9w TXVsKER5bmFtaWNNYXRyaXggbSkgey4uLn0KICAgICAgICAuLi4KICAgfQoKSSB0aGluayB0aGlz IHdpbGwgd29yayBmaW5lIHdpdGggRE1EIGFzIGxvbmcgYXMgeW91IGhhdmUgYm90aApEeW5hbWlj TWF0cml4IGFuZCBTdGF0aWNNYXRyaXggaW4gdGhlIHNhbWUgZmlsZS4KCklmIHlvdSAqZG8qIHdh bnQgdG8gcHV0IHRoZW0gaW4gc2VwYXJhdGUgbW9kdWxlcywgdGhlbiwgeWVzLCB5b3Ugd291bGQK cHJvYmFibHkgcnVuIGludG8gdHJvdWJsZS4KCkl0IGlzIGtpbmQgb2YgYW5ub3lpbmcgdGhhdCBp c3N1ZXMgbGlrZSB0aGlzIGVuZCB1cCBkaWN0YXRpbmcgaG93CnNvdXJjZSBjb2RlIGlzIHNwbGl0 IGFtb25nIGZpbGVzIGluIEQuICBJIHJlYWxseSB0aGluayBpdCBzaG91bGQgYmUKKm15KiBjaG9p Y2UgdG8gc3BsaXQgdXAgYSBmaWxlIGlmIEkgdGhpbmsgaXQncyBnZXR0aW5nIHRvbyBiaWcuCgot LWJiCg==
Dec 17 2008
Bill Baxter пишет:2008/12/18 Weed <resume755 mail.ru>:segmentBill Baxter пишет:On Thu, Dec 18, 2008 at 2:05 PM, Weed <resume755 mail.ru> wrote:Feature request: Deploying a class instance in the default datasliceand creation of a class instance at compile time. In this post I'll try to prove the necessity of this feature. I have found that in D it is impossible to create a polymorphic object (class or struct) which can be created at compile-time. Good specific example of such an object is a matrix class. For some matrices it is good to create and initialize them at compile time, not dynamically at run time. Also for matrices of predefined size it is wrong to duplicate their dimensions (their width and height should be declared invariant and, consequently occupy memory only once) At the same time dynamically created matrices of arbitrary size which can be changed at run time are also needed. For example to make acopy it.of giant matrix it's more efficient to modify it in-place than tosized withThese matrices have variable width and height. So we have minimum two types of matrices: dynamic and constantmatrix andability of compile time initialization. It is necessary to provide interaction between them (for example overload arithmetic operators for them). For this purpose it is necessary for them to be inherited from common parent.This point I don't think is true. DynamicMatrix can implement methods like opMult(StaticMatrix M), and vice versa.I think this is impossible. If I create struct for compile-timeinteractionclass for all other I will not be able to create a methods fortype ofbetween these objects through the templates because some of them will be announced before the other and it will not be able to get anotherYesobject in a template.You mean there will be this circular dependency?struct DynamicMatrix { DynamicMatrix opMul(StaticMatrix m) {...} ... } struct StaticMatrix { DynamicMatrix opMul(DynamicMatrix m) {...} ... } I think this will work fine with DMD as long as you have both DynamicMatrix and StaticMatrix in the same file. If you *do* want to put them in separate modules, then, yes, you would probably run into trouble.Yes. In addition, in the overloaded methods will probably need to implement a different mechanism for creating all types of matrices (this need for returning values), eg, static and non-resizeable matrix template will have to pass an array pattern in a string like this (very cumbersome): ========================================== char[] matBySize(int size) { char[] init; for (int i = 0; i < size; i++) { init ~= "["; for (int j = 0; j < size - 1; j++) { init ~="0, "; } init ~= "0]"; if (i == size - 1) init ~= "]"; else init ~= ",\n"; } return "mat([" ~ init ~ ")"; } struct mat { int[][] value; static mat opCall(int[][] init) { mat m; m.value = init; return m; } mat opPostInc() { foreach (row; value) { foreach (ref item; row) { item++; } } return this; } } void myFunc() { static sm = mixin(matBySize(2)); auto dm = mixin(matBySize(3)); } // (thanks naryl for this code sample) ========================================== In addition, if I want to add other types of matrices (I have already talked about the matrix, which is part of another matrix) it will be difficult to do so, because the structures do not support the interfaces and will have to manually monitor so that all methods have been implemented correctly. Figuratively speaking, in the spirit of the matrix is class, not the structure.It is kind of annoying that issues like this end up dictating how source code is split among files in D. I really think it should be *my* choice to split up a file if I think it's getting too big. --bb
Dec 17 2008
Bill Baxter пишет:On Thu, Dec 18, 2008 at 2:05 PM, Weed <resume755 mail.ru> wrote:Here other example: Suppose a matrix structure implemented "Dynamic" and "Static" using the template mixins. On this basis must be built other structures (for example, the structure of "image" is a dynamic matrix with additional features, the structure of "pixel" is a matrix of 3x1). Functional of matrix structures "Static" and "Dynamic" included in the structure of "image" and "pixel". So far, so good. But in this case becomes impossible to implement matrix multiplication operation type, return other than the size of the source matrix, just as implemented in http://www.dsource.org/projects/openmeshd/browser/trunk/LinA g/linalg/MatrixT.d, template "template MultReturnType (ArgT)" - we will not be able to create a matrix of different dimensions but the same type as the original matrix, because we will have to list in this template "MultReturnType" all structures "image", "pixel", etc. If the matrix would be a class that would be to return the reference to base type matrix enoughFeature request: Deploying a class instance in the default data segment and creation of a class instance at compile time. In this post I'll try to prove the necessity of this feature. I have found that in D it is impossible to create a polymorphic object (class or struct) which can be created at compile-time. Good specific example of such an object is a matrix class. For some matrices it is good to create and initialize them at compile time, not dynamically at run time. Also for matrices of predefined size it is wrong to duplicate their dimensions (their width and height should be declared invariant and, consequently occupy memory only once) At the same time dynamically created matrices of arbitrary size which can be changed at run time are also needed. For example to make a slice of giant matrix it's more efficient to modify it in-place than to copy it. These matrices have variable width and height. So we have minimum two types of matrices: dynamic and constant sized with ability of compile time initialization. It is necessary to provide interaction between them (for example overload arithmetic operators for them). For this purpose it is necessary for them to be inherited from common parent.This point I don't think is true. DynamicMatrix can implement methods like opMult(StaticMatrix M), and vice versa. The only thing I can think of you can't do is make an array of pointers to Matrix, the elements of which might be a DynamicMatrix, or might be StaticMatrix. But even that, if you really feel you need it for some reason, could be done using a struct/class with a union inside. Most cases where you might want to accept either/or can be done with templates.So it can not be structures, only classes. But classes can not be created at compile time. So I propose to add possibility of deployment of class instance in the default data segment and creation of class instance at compile time.This might be a useful feature, but I'm not finding your argument for it quite convincing enough yet.
Dec 21 2008
Weed Wrote:For some matrices it is good to create and initialize them at compile time, not dynamically at run time.Oh, yes, how could I forget about some matrices... :)
Dec 18 2008
Weed пишет:Feature request: Deploying a class instance in the default data segment and creation of a class instance at compile time. In this post I'll try to prove the necessity of this feature. I have found that in D it is impossible to create a polymorphic object (class or struct) which can be created at compile-time. Good specific example of such an object is a matrix class. For some matrices it is good to create and initialize them at compile time, not dynamically at run time. Also for matrices of predefined size it is wrong to duplicate their dimensions (their width and height should be declared invariant and, consequently occupy memory only once) At the same time dynamically created matrices of arbitrary size which can be changed at run time are also needed. For example to make a slice of giant matrix it's more efficient to modify it in-place than to copy it. These matrices have variable width and height. So we have minimum two types of matrices: dynamic and constant sized with ability of compile time initialization. It is necessary to provide interaction between them (for example overload arithmetic operators for them). For this purpose it is necessary for them to be inherited from common parent. So it can not be structures, only classes. But classes can not be created at compile time. So I propose to add possibility of deployment of class instance in the default data segment and creation of class instance at compile time.In more general terms: Structures and classes must be identical except that the structure can not have inheritance, and classes can not be assigned by value (to prevent slicing). Everything else, including constructors, and static initialization they must match. (Yes, of course structures have alignment control and other pieces for the Plain Old Data)
Dec 18 2008