Stack overflow when I am trying to make a composite type with a matrix as a field

Question

In the following code, I have a composite type, and in my real code several of the fields are matrices. In this example is only 1. I keep getting stack overflow when I try constructing the composite type. Here is the code sample:

struct Tables
    eij::Array{Float64,2}
end

Tables(eij::Array{Float64,2}) = Tables(eij) # works if this is commented out
x = 5   # arbitrary matrix dimension    
e_ij = Array{Float64,2}(undef,x,x)

for i=1:x
    for j=1:x
        e_ij[i,j] = i*j/2.3     #dummy numbers, but not the case in real code
    end
end

vdwTable = Tables([e_ij[i,j] for i=1:x,j=1:x])

I use the temporary variable e_ij to make the matrix first since I don't want the composite Tables to be mutable. So, my reasoning is that by generating the tables first in dummy variables like e_ij, I can then initialize the immutable Tables that I really want.

If I comment out the outer constructor for the struct Tables it works. However, I actually want to have several different outer constructors for cases where different fields are not passed data to be initialized. In these cases, I want to give them default matrices.

The error I get is the following: ERROR: LoadError: StackOverflowError: on the line vdwTable = Tables([e_ij[i,j] for i=1:x,j=1:x])

I was basing this on a similar approach I used for composite types with vectors, however, I was also using parametric types. I think the use of parametric types is what made defining the type on the Left Hand Side of the outer constructor work... But I do not know why... If I leave the LHS as Tables() or Tables(eij) it works... — Charlie Crown

DNF DNF · Accepted Answer · 2019-02-05T08:20:54

When you define a composite type, an inner constructor is automatically defined, so this:

struct Tables
    eij::Array{Float64,2}
end

is equivalent to this:

struct Tables
    eij::Array{Float64,2}
    Tables(eij::Array{Float64,2}) = new(eij)
end

When you define this outer constructor

Tables(eij::Array{Float64,2}) = Tables(eij)

you get in the way of the inner constructor. Your outer constructor just calls itself recursively until you get a stack overflow.

Doing this, on the other hand,

Tables(eij) = Tables(eij)

is actually equivalent to this:

Tables(eij::Any) = Tables(eij)

so when you subsequently call

vdwTable = Tables([e_ij[i,j] for i=1:x,j=1:x])

it then just ignores your outer constructor, because there is a more specific method match, namely the inner constructor. So that particular outer constructor is quite useless, it will either be ignored, or it will recurse until stack overflow.

The simplest solution is: just don't make an outer constructor. If you do need an outer one to enforce some conditions, make sure that it doesn't shadow the inner constructor by having the same type signature. For example,

Tables() = Tables(zero(5, 5))

should work.

I would probably do it like this, though:

struct Tables
    eij::Array{Float64,2}
    Tables(eij=zeros(5, 5)) = new(eij)
end

For your second example, with two fields, you can try this:

struct Tables
    eij::Array{Float64,2}
    sij::Array{Float64,2}
    Tables(eij=zeros(5,5), sij=zeros(5,5)) = new(eij, sij)
end

Your inputs will be converted to Float64 matrices, if that is possible, otherwise an exception will be raised.

Stack overflow when I am trying to make a composite type with a matrix as a field

2 Answers