unbalance | unRAID app to free space | File Utils library

There are essentially two problems in your code:

1. There are several places where you access the ->Height member of a NULL reference. Instead, always use the function Height when you need to get that information from a reference which might be NULL. Fix this in both single rotation functions, and in the Insert function.

2. The Insert function may perform a rotation on the root node, so it may return a different root reference. This means that the caller must always take the returned value and assign it to its own root reference. You have not done this in the main program.

As a side note, I find it useful for debugging to have a print function that prints the tree in in-order sequence with depth-indentations, so you can actually see its structure.

Here is your code with the 2 issues corrected, and the additional print function:

I think this is not so much a programming question but rather a statistical question. Also I think it is not so much a question about the capabilities of package "plm" per se but rather if such a within model makes sense and the technical estimation approach to within models implemented.

plm's within models (fixed effect models) do not contain an intercept. Some other statistical software packages have a somewhat artifical intercept in their within models (most notably probably Stata, but gretl as well). You may want to look at ?plm::within_intercept and the literature it references for more details about the intercept in within models.

Let's see what happens in case of only an intercept as regressor in a within model:

I created an issue with the following idea:

You cannot easily upsample as this is a multilabel case (what I've missed from the post originally).

What you can do is give 1 way higher weights, something like this:

'm having a hard time implementing a queue that satisfies the last point while keeping acceptable performance. I'm using pthreads to do the synchronization and, in order to satisfy the FIFO requirement, I am relying on pthread_cond_wait and pthread_cond_broadcast functions.

In this case, when a thread adds to the queue it does a pthread_cond_broadcast() and wakes up all threads that were blocked waiting to fetch data from the empty queue; and (if there's lots of threads that were blocked waiting) this causes lots of CPU time to get wasted by thread switches and scheduler overhead; because each waiting thread unblocks, tries to acquire a mutex (and probably blocks and unblocks again while trying to get the mutex) then checks to see if it's next, and then blocks again if it isn't next.

To fix that; each thread needs its own separate condition variable. When a thread starts waiting for data from an empty queue it puts its condition variable on a "queue of waiting readers"; and when a thread adds data to the queue it takes the first condition variable from the "queue of waiting readers" and (if there is a waiter) does one pthread_cond_signal() (and not a broadcast) so that only one waiting thread is unblocked.

Note that the "queue of waiting reader's condition variables" can be a linked list of "struct waiter { struct waiter * next; pthread_cond_t condVar; }" structures; and these structures can be created and initialized when a thread is created and then continually recycled (until the thread terminates).

For "multiple writers" it's essentially the same problem with the same solution (and can re-use the same "struct waiter" created when the thread was created). When a thread needs to wait to add data to the queue it adds its condition variable to a "linked list of waiting writers" and when a thread finishes removing data from the queue it does one pthread_cond_signal() to unblock the next waiting writer.

Note that this should significantly improve performance when its under high contention (lots of waiting readers or lots of waiting writers); but the extra overhead of managing "queues of waiters" may also reduce performance under low contention (worst case is when there's regularly only one waiting thread, which is the best case for your current approach using pthread_cond_broadcast).

tl;dr use expand.grid() or something like it to generate a balanced/evenly spaced sample for every group (if you have a strongly nonlinear curve you may want to generate a larger/more finely spaced set of x values than in the original data)

You could also take a look at the sjPlot package, which does a lot of this stuff automatically ...

You need both an unbalanced data set and a non-linear (e.g. polynomial) model for the fixed effects to see this effect.

• if the model is linear, then you don't notice missing values because the linear interpolation done by geom_line() works perfectly
• if the data are balanced then there are no gaps to get weirdly filled by linear interpolation

Generate an example with quadratic effects and an unbalanced data set; fit the model

We can use complete from the tidyr package. The key is to set nesting properly.