lists v. np.arrays

[dmdunla]

There are a lot of places where we need lists of integers/indices, and the current APIs require using np.array.

I think we should allow either lists or np.arrays in such cases? For example, consider the following code:

import numpy as np
import pyttb as ttb
X = ttb.tensor.from_data(np.ones((2,2,2,2)))
U = np.ones((2,))

# these work
X.ttv([U,U],dims=np.array([0,2]))
X.ttv([U,U],exclude_dims=np.array([1,3]))
X.ttv([U],dims=0)
X.ttv([U],exclude_dims=[1,2,3])
X.ttv([U],exclude_dims=np.array([1,2,3]))
X.ttv([U,U,U],exclude_dims=3)

# this does not work
X.ttv([U,U],dims=[0,2])

The fact that the latter does not work may be confusing for users, as it is not consistent.

Allow for lists or np.array also leads to more readable code when using lists.

[ntjohnson1]

I believe this was for expediency in the initial support since all the MATLAB stuff only had the singular format. I agree that the current support is overly restrictive.

Typing may help here since it can statically check that we support the input types we claim to. We can probably support general iterables (but I'd have to look more closely). We probably could steal numpy's generic type for things they can coerce into an array, or create our own index type based on the integer restriction. Will probably want to create some utility around this to reduce code duplication.

I think the fact we support lists for exclude_dims but not dims is accidental.

[tgkolda]

I was going to post a separate comment about this. It's really confusing to me to understand when an np array is needed versus just a list or a tuple.

[ntjohnson1]

If you have or could collect examples of situations you run into this that would be useful for scoping the solution.

I looked into this a little bit and it looks like for numpy they support more flexibility but intentially don't advertise the breadth of the type support.

For example these all work but their documentation states the shape argument must be a tuple

>>> np.ones((2,2,2))
>>>np.ones([2,2,2])
>>>np.ones(np.array([2,2,2])))

[tgkolda]

Ok - I'll try to document all the places I find such situations.

[ntjohnson1]

Thanks! I already agree making shape more flexible aligns with other standards. I expect applying that to all flat/1d structures makes sense and isn't too bad. Curious to see if there's confusion with more complex data structure arguments.

[tgkolda]

Situations

• X.ttv([U,U],dims=[0,2]) - does not work (see comment above)
• sparse = ttb.sptensor(subs, vals, shape=tuple(shape.flatten())) - Would like shape to be more flexible!

[ntjohnson1]

We merged a PR that made our lists of indices much more flexible. I think anywhere we've missed can be managed via follow up issues.