pfi | PFI

What you're doing is valid. As long as you're calling the pointed-to function via the proper pointer type, it's well defined.

This union could get big however depending on how many different function types you have to support, and you have to keep it in sync with your set of typedefs. As it turns out you can freely convert from one function pointer type to another via a cast, you just need to make sure you call it with the proper type.

Section 6.3.2.3p8 of the C standard say the following about function pointer conversions:

A pointer to a function of one type may be converted to a pointer to a function of another type and back again; the result shall compare equal to the original pointer. If a converted pointer is used to call a function whose type is not compatible with the referenced type, the behavior is undefined.

So you could also just use void (*)() as a generic pointer type instead of using a union, then you would need to apply the proper cast when you call it. For example:

Because you are using the same data set clean4 for producing output in three different ways for each ID you need to change only a minimal amount of code when you convert to macro (macroize) the existing code.

Two steps

• macroize existing code to operate on a single 'ID' value (the do'er)
• run the macro for each ID (the run'er)

Do'er

This is what I would do (not seeing the full code it is hard to write a full solution (also this will eat up a lot of memory, but again - in order to optimize this I would need to see the code; what I write has a benefit of being simple to implement and not require locking).

So the recommendation is:

1. create cr2_vec = [copy(cr1) for i in 0:499]
2. in outer loop write cr2 = cr2_vec[k]
3. Then do all the processing on cr2
4. after the @threads loop finishes take cr2_vec, which will have updated data frames and from each data frame of this vector take the columns that are needed and add it to your original cr1 data frame.

A more advanced solution would be not to use a vector of data frames, but just a single data frame, as you do, but after the computing is done use a lock and within a lock update the global cr1 with only the computed columns (you need to use lock to avoid race condition).

EDIT

An example of a more efficient implementation:

. means from current package. Hence, this line means:

I'm working with the IB API every day. Therefore I would prefer to get the ISIN with the function

reqFundamentalData

You have to use 4 arguments and the third is called reportType. Here you can choose the easiest type named ReportSnapshot. You will receive a xml-file and in the second part (Common Stock) you find the line with the ISIN. For example in the request for AAPL:

US0378331005

It's not so complicated. If you need sample code just ask me.

More informations: IB about reqFundamentalData and documentation of the function

Like the commenter said. You should take the fft the second time. This is because the output from the rfft of the rows is complex. This solves the complex to real error, as well as the shape problem.

It seems that setting velocity[1, mesh.facesTop.value] = v0 ensures that the inflow and outflows are balanced making it easier to achieve continuity. Now, for this problem,

https://pages.nist.gov/pfhub/benchmarks/benchmark5-hackathon.ipynb/

it's suggested that the zero pressure correction value is set near the outlet. Trying that with your code seems to improve things,

Not really sure, because I did not fully understand your desired output... But here is a go using the data.table-package

Unfortunately, periodic meshes are currently broken for parallel runs.