Hello

I have seen this : https://forum.dlang.org/thread/1473526717.1917.20.camel@winder.org.uk

Now, please consider this code:

import std.stdio;
import std.math;
import std.stdio;
import std.conv;
import std.format;
import std.math;
import std.algorithm;
import std.net.curl;
import std.json;
import std.path;
import std.array;
import std.net.curl;
import core.stdc.stdlib;
import std.datetime;
import std.file;

void main() {

    auto a = new double[][] (0,0);
    a ~= [ 1.0, 2.45];
    a ~= [ 4.9 ,28, 9];



    auto b = a.dup;

    a[1] = remove(a[1],1);

    writeln(b);

}

I compile with dmd version :

DMD64 D Compiler v2.096.1

Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved written by Walter Bright

Output :

[[1, 2.45], [4.9, 9, 9]]

What I would expect :

[[1, 2.45], [4.9, 28, 9]], because i am copying the array a to a different place - at b.

Is this normal behavior of dup? if so, how can I get the behavior i am searching for? Thank you.

On Wednesday, 2 June 2021 at 15:32:38 UTC, Sean wrote:

    auto a = new double[][] (0,0);
    a ~= [ 1.0, 2.45];
    a ~= [ 4.9 ,28, 9];



    auto b = a.dup;

    a[1] = remove(a[1],1);

    writeln(b);

it's rather an unintuitive behavior.
.dup is not a deep copy:

import std;

void main() {

auto a = new double[][] (0,0);
a ~= [ 1.0, 2.45];
a ~= [ 4.9 ,28, 9];



auto b = [a[0].dup, a[1].dup];

a[1] = remove(a[1],1);

writeln(b);

}

works as you expect

On Wednesday, 2 June 2021 at 15:59:38 UTC, Basile.B wrote:

On Wednesday, 2 June 2021 at 15:59:38 UTC, Basile.B wrote:

import std;

void main() {

    auto a = new double[][] (0,0);
    a ~= [ 1.0, 2.45];
    a ~= [ 4.9 ,28, 9];



    auto b = [a[0].dup, a[1].dup];

    a[1] = remove(a[1],1);

    writeln(b);
}

works a expected. The reason why is that your array elements are fat pointers, so when you dup a, you dup some fats pointer, so you got the same elements as "a" but accessible from another chunck of memory.

On Wednesday, 2 June 2021 at 15:59:38 UTC, Basile.B wrote:

Okey, so I have to copy every (N-1) dimensional element - one after one - if the array is N dimensional, with N > 1, and repeat it for every element if they themselves are arrays with dimension M > 1 ?

This becomes very difficult if we have large tensors, 16 - 85 dimensions ( I am doing AI with d ) and eash element itself is a dynamic array.

On Wednesday, 2 June 2021 at 16:08:14 UTC, Sean wrote:

you should use library types for this kind of operations, for example they can provide virtually N dim arrays that are actually flattened. Maybe Mir would help.

On Wednesday, 2 June 2021 at 16:18:03 UTC, Basile.B wrote:

Tried.

However, I am more of a mathematician, than a software developer. So writing my own code was easier than to follow through the design philosophy and internalize the idioms and styles of Mir.

When this project is done, I will study Mir more in detail

On Wednesday, 2 June 2021 at 16:07:35 UTC, Basile.B wrote:

Would it be worth modifying the docs for .dup() so that this behavior is clear?

I would have been confused by this as well. It's probably a no-brainer if you understand general memory principles but not everyone does.

On Wednesday, 2 June 2021 at 16:50:16 UTC, Gavin Ray wrote:

yes, I think so, it's worth a dlang.org change.

Me too actually. the reason why this did not work as expected was not immediate.

On Wednesday, 2 June 2021 at 15:32:38 UTC, Sean wrote:

My current solution, if anyone wonders : https://github.com/patefacio/d-help/blob/master/d-help/opmix/dup.d