uarray | A general dispatch and override mechanism for Python

I just want to index elements, maybe turn it back into a linked list, but I can't seem to figure out how.

It is in the documentation of IArrays:

(!) :: (IArray a e, Ix i) => a i e -> i -> e

Returns the element of an immutable array at the specified index.

...

elems :: (IArray a e, Ix i) => a i e -> [e]

Returns a list of all the elements of an array, in the same order as their indices.

Regarding

that doesn't seem to list possible manipulations, either.

note that these are immutable arrays, so you can't really manipulate them much.

Your test uses Data.Array.elems which only works on Array.

You need to call instead the class method Data.Array.IArray.elems which works on any immutable array, including UArray.

Following code might help you

see scipy import fails for WPy64-3770 https://github.com/winpython/winpython/issues/849

EDIT

Create one method to validate your JSONObject

If you're API 19+, might as well stick with encoding method #2, getImage()/encodeVideoFromImage(), since that is more modern.

Focusing on that method: One problem was, you had an unexpected image format. With COLOR_FormatYUV420Flexible, you know you're going to have 8-bit U and V components, but you won't know in advance where they go. That's why you have to query the Image.Plane formats. Could be different on every device.

In this case, the UV format turned out to be interleaved (very common on Android devices). If you're using Java, and you supply each array (U/V) separately, with the "stride" requested ("spacer" byte in-between each sample), I believe one array ends up clobbering the other, because these are actually "direct" ByteBuffers, and they were intended to be used from native code, like in this answer. The solution I explained was to copy an interleaved array into the third (V) plane, and ignore the U plane. On the native side, these two planes actually overlap each other in memory (except for the first and last byte), so filling one causes the implementation to fill both.

If you use the second (U) plane instead, you'll find things work, but the colors look funny. That's also because of the overlapping arrangement of these two planes; what that does, effectively, is shift every array element by one byte (which puts U's where V's should be, and vice versa.)

...In other words, this solution is actually a bit of a hack. Probably the only way to do this correctly, and have it work on all devices, is to use native code (as in the answer I linked above).

Once the color plane problem is fixed, that leaves all the funny overlapping text and vertical striations. These were actually caused by your interpretation of the RGB data, which had the wrong stride.

And, once that is fixed, you have a decent-looking picture. It's been mirrored vertically; I don't know the root cause of that, but I suspect it's an OpenGL issue.

I can reproduce this, the print is what is taking forever. Or rather, it is the conversion to string implicitly called by print. I used line_profiler to measure the time of the __format__ function of AffineScalarFunc. (It is called by __str__, which is called by print) I decreased the array size from 8200 to 1000 to make it go a bit faster. This is the result (pruned for readability):

Update: I think I finally understood what's going on. array is lazy on the list elements, but is unnecessarily strict on its spine!

This causes a <> exception, for instance

I found my answer for this problem after checking and trying out the other exmple given in https://github.com/mhwombat/som/blob/master/examples/colours.hs

Using the function euclideanDistanceSquared and adjustVector provided by the som lib instead of my defined ones worked for me.