eru | High Level Framework for PyTorch | Machine Learning library

You can use cross apply to unpivot and then reaggregate:

I think the issue here is that you are making a "shallow copy", not a "deep copy". See here for more information.

As a fix, try importing copy:

my struct has a lot of data within it (around 50 strings) and copying it over sounds inefficient and a hassle.

...

void printVerbs(verbType verbArray[VERBS], int count);

First, start using C++ containers like std::vector or QVector instead of raw C arrays. The C++ container classes are much easier to manage and debug.

Then, you can cheaply pass arrays around by const reference:

void printVerbs(const QVector &verbArray);

Note: You don't need to pass count! The vector knows how many elements it contains.

This achieves 2 things:

• The reference part ensures that your data is not copied during the function call, because the function is referencing the data that already exists
• The const part ensures that the function cannot accidentally modify your existing data.

QVector is implicitly-shared (also called "copy-on-write"): https://doc.qt.io/qt-5/implicit-sharing.html This means you can pass a copy of QVector from your MainWindow into your TenseSelectionDialog and even store a copy as a member variable in TenseSelectionDialog. As long as neither copy is modified, both vectors will share the same data internally.

Alternatively, if you guarantee that MainWindow will always outlive TenseSelectionDialog, then you can have TenseSelectionDialog store a pointer or reference to MainWindow's member variable.

I also don't know whether I should make it an array of pointers to structs if that'd be the way to go.

Using an array-of-pointers is most useful if:

• Your array will get modified or copied frequently.
  • Inserting or removing elements can cause the array contents to be moved in memory.
  • It is cheaper to move/copy pointers than large structs.
• Your array will be huge.
  • Data in an array is stored in a contiguous memory block, given by N * sizeof where N is the number of elements.
  • If your memory is too fragmented, your PC might not have a large enough contiguous block of RAM to store the data.
  • For large structs, storing pointers reduces the amount of contiguous memory needed.

If these 2 criteria don't apply, then there's less benefit in using an array-of-pointers. (Hint: ~500 elements is tiny)

If you want to use an array-of-pointers, do use std::shared_ptr instead of raw pointers so that you don't need to manage the memory explicitly.

If you're willing to use QString in your core logic, your string manipulation code could be simplified greatly.

Example:

Arrays.binarySearch does return an int, therefore there is no compareTo method. Your code doesn't compile.

To fix it, change the conditional part like this:

One solution is to add text to Dataframe and then use .str.extract() to clear your data:

use cte

Code: (Demo)

You need to tell XmlSerializer (or rather, the underlying XmlReader) that it is safe to expand XML entity references by setting XmlReaderSettings.DtdProcessing = DtdProcessing.Parse like so:

mention java code in onCreateOptionsMenu()