jagged | java bindings to libgit2 | Machine Learning library

Great question, unfortunately, I don't see an easy way to do that. Here is a sketch of some ideas; I'll try to come back in the next day or two to fill in the details.

First of all, I thought about replacing if/then/else with unit_step, charfun, or charfun2. However, it looks like simplifications for arithmetic on those expressions (e.g. product of unit_step) isn't implemented, so working with any of those wouldn't be any simpler. But if someone else can see how to do it, please, by all means, show us.

The outline of a way that I see to do this is (1) define rules for arithmetic on if/then/else, and (2) define rules for flattening nested if/then/else. I would use defrule to define the rules, although tellsimpafter is also a possibility.

EDIT: I've put together some code to handle (1) and (2) above. See robert-dodier/simplify_conditionals at: https://github.com/maxima-project-on-github/maxima-packages

Here's the result I get for the problem you mentioned.

You have to create an OpenGL window with frame buffer configured for multisampling (see Creating an OpenGL context ans Specifying the OpenGL context properties):

Rather than working out the average on the fly you should calculate it at the end only by moving avg = sum / i; outside of the nested loop otherwise it will divide by an incorrect every time it loops. Also use avg = sum / arr[r].length; instead because we know exactly how many columns each row has:

Yes, there's no reason why constexpr std::initializer_list would be unusable in compile-time initialization.

From your code snippet, it's unclear whether you've used an in-class initialization for StaticArray members, so one of the issues you could've run into is that a constexpr constructor can't use a trivial constructor for members which would initialize them to unspecified run-time values.

So the fix for your example is to default-initialize StaticArray members and specify constexpr for the constructor, checkDims, addList and data. To initialize a runtime StaticArray with constexpr std::initializer_list validated at compile-time, you can make the initializer expression manifestly constant-evaluated using an immediate function.

As you probably realize, it is impossible to initialize a run-time variable at compile-time so that's the best one can do.

If what you wanted is to validate at compile-time the dimensions of an std::initializer_list that depends on runtime variables, it can't be done -- the std::initializer_list is not constexpr, so its size isn't either. Instead, you can define a wrapper type around Scalar, mark its default constructor as deleted, and accept an aggregate type of these wrappers in the StaticArray constructor, for example a nested std::array of the desired dimensions, or, to avoid double braces, a C-style multidimensional array. Then, if the dimensions don't match, compilation will fail for either of the two reasons: too many initializers or the use of the deleted default constructor.

The code below compiles on godbolt with every GCC, Clang, MSVC version that supports C++20.

In order to make the solution allowing multiple cells entry from the Callendar, but also allowing multiple deletions, please adapt it in the next way:

1. Use this modified code in the module where Basic_Calendar Sub exists:

There are a few solutions to this, discussed in this Medium article by Mandy Michael.

One elegant one is to use calc to add a single pixel of the second color, as seen below, which renders enough blur to offset the jaggedness.

The issue is that the NumSharp data-structure is a heavy RAM consumer and it seems to be the CSharp GC is not aware of what NumSharp is allocating so it reaches the RAM limit very fast.

So, In order to overcome this, I split the input npy file so that every part should not consume more than max memory allocation allowed in C# (2147483591). In my case i split into 5 different files (200k vectors each).

python part to split the large .npy file:

Since the canvas context also accepts HTMLImageElement as an input, using createImageBitmap() is redundant here. Instead, we return the DOM loaded itself, thus circumventing createImageBitmap(), which obviously caused the jagged edges. Thanks to @Kaiido.