rop | A lightweight command line option parser written in Java | Command Line Interface library

EDIT: made a few changes, including swapping out for a non-regex pattern match (still fast).

Tested on your sample data.

gmpxx.h contains interfaces to some mathematical operations like sqrt (see line 3341)

Unfortunately you text file is not a typical CSV file, delimited by some character like a comma or such. The entries in the lines seem to be separated by tabs. But this is a guess by me. Anyway. The structure of the source file makes it harder to read.

Additionally, the file has an header and while reading the first line andtry to read the word "ID" into an int variable, this conversion will fail. The failbit of the stream is set, and from then on all further access to any iostream function for this stream will do nothing any longer. It will ignore all your further requests to read something.

Additional difficulty is that you have spaces in data fields. But the extractor operator for formatted input >> will stop, if it sees a white space. So, maybe only read half of the field in a record.

Solution: You must first read the header file, then the data rows. Next, you must know if the file is really tab separated. Sometimes tabs are converted to spaces. In that case, we would need to recreate the start position of a field in the a record.

In any case, you need to read a complete line, and after that split it in parts.

For the first solution approach, I assume tab separated fields.

One of many possible examples:

The language of expressions that you describe isn't regular. So you'll have to use a different library.

Luckily, essentially the same parser structure should work fine with most other parser combinator libraries. It should be as simple as substituting your new library's name for a few basic parsers in place of their regex-applicative analogs.

The reason why the expression arr[index:-1, index:-1] = arr[index + 1:, index + 1:] is slow in both Numpy and Cython and the Cython code is much faster is a bit counter intuitive: this expression is not efficiently implemented in both Numpy and Cython.

Indeed, Numpy copy the right-hand side (arr[index + 1:, index + 1:]) in a temporary array allocated on-the-fly. The temporary array is then copied to the left-hand side (arr[index:-1, index:-1]). This means that two memory copy are performed while only one could be used. It is even worse: the copied memory is pretty big and will not fit in the cache resulting in a bigger overhead (on some processors, like the mainstream x86/x86-64 ones, the write-back policy cause additional slow reads). Moreover, the new temporary array will cause many page fault slowing down even more the copy.

Numpy do this because the left-hand side and the right-hand side may overlap (which is the case here) and thus the order in which the memory bytes are copied matter a lot. Numpy use a slow conservative approach rather than an optimized implementation. This is a missed optimization. Cython does exactly the same thing.

Your Cython code do not suffer from all these overheads: it directly copy the array in-place relatively efficiently. The value read are kept in the cache and then written just after so that the write-back policy is not an issue. Moreover, there are no temporary array nor page faults. Finally, your Cython code do not copy the lower-part of the triangular matrix resulting in fewer bytes to be copied compared to the expression previously mentioned.

One way to reduce the overhead of the Numpy expression is to copy the matrix chunk-by-chunk and allocates a small temporary buffer for that (typically few lines of the matrix). However, this is far from being easy since CPython loops are generally very slow and the chunk size should fit in cache so the method can be useful...

Further optimization: conditionals are slow. You can remove them by starting the j-based loop at i+1 and ending it at n-1. Another j-based loop can then fill the value greater than n-1. For the same reason, the i-based loop should end at n-1 and another loop can then fill the remaining part of the array. A good compiler should use faster SIMD instructions.

I figured out that due to the way mpz_t variables work the mpz_set function does not work with a pointer to mpz_t type variables as a parameter.

Instead, I was able to get the program to work by assigning the mpz_get_str function to a string and pushing that to a vector of strings to check for repeat values.

The AAAA are because on entry to flag, it expects the top of the stack to contain its return address, with arguments starting 4 bytes past that. You don't care about flag being able to return, so you just need 4 bytes of garbage in place of the return address.

As for the \r, it isn't between the arguments (they should be adjacent in memory and there can't be any bytes between them); rather it is actually the first (least-significant) byte of the second argument. The ASCII carriage return \r has numerical value 0x0d, so your arguments are 0xdeadbeef, 0xc0ded00d. I don't know why they wrote the low byte as \r instead of \x0d which would have been more consistent. Maybe it was automatically translated from binary to hex escapes by some program.

It looks like you want to pull out the inner text of the ParameterList node inside the XML. You can use .value and XQuery for this:

Your src attribute for the img tag will be something like this