BMAX | Bag of Max Words

Hello and welcome to the site. Interesting problem.

Your problem appears to be set up correctly. You are getting the "massive discharge" because you are artificially (?) constraining the battery to be at its maximum charge in the middle of the night at time=0 (assessed by looking at the periodicity of your solar energy). This would cause the battery to be artificially too large, because it doesn't need to be at max capacity at that particular time... Optimally, it should be at peak charge when the requirement becomes greater than PV generation, right?

So, it is taking a massive dump in the middle of the night to shed this charge, which (in your model) is penalty free. See the plot below from your data truncated to 5 periods:

So, what can be done? First, un-constrain your battery at t=0. This will allow the model to pick an optimal initial charge. You may still see anomalous behavior because the model could still keep a higher than necessary charge there and discharge as that scenario has the same objective score. So, you may choose to put a tiny penalty on cumulative discharge to influence the model. Realize this is artificially increasing the cost of battery usage very slightly, so be judicious [check this by making the discharge penalty huge in my code below and see the difference]. Or you could just ignore this, truncate the first cycle as "warm up", etc...

Here is result with no starting constraint for battery and a tiny discharge penalty...

You can group your data by their transport_mode and for consecutive stretches of 'B' modify them:

I was surprised to see that Seaborn does not perform the layering (i.e., which point goes above another point) in the order that the points are passed, since Matplotlib definitely does that, and Seaborn is built atop Matplotlib.

Following Matplotlib's ordering, you would want the point [a=0.854297, c=0.056573] (i.e., the point being hidden) to be plotted after the other two points close to it [a=0.854297, c=0.050635] and [a=0.854297, c=0.058926]. This is so that [a=0.854297, c=0.056573] is plotted last and hence not masked.

Since Seaborn does not seem to do this out of the box, I reordered [a=0.854297, c=0.056573] to be plotted last.

So I seem to have stepped around the problem successfully, albeit not gracefully.

As stupid as it is, I installed the gem on a working native Ubuntu box without issue, and then I copied my rbenv installation of ruby 2.7.4 from that machine over to this one (located at ~/.rbenv/versions/2.7.4), overwriting my local installation of that ruby version completely. Obviously I probably could have just moved gem-specific files and this solution clobbered gems I already had installed, but that's fine. When I ran a bundle install on my newly-generated rails project, it installed everything else and used the existing sqlite3 gem without complaint. When using irb, I am able to require the gem without issue.

If some subtle behaviour emerges that shows that this doesn't actually work and just sidesteps the first obvious appearance of the issue, I'll edit or delete this answer. If it appears to work and nobody submits something that fixes the root problem in the next few days, then I'll just accept this answer.

This seems like a very unusual way to write an R function, but you could do

You are using the values of your arrays a and b as the indices of the matrix M. What you want is M[x,y] = mandelbrot(a[x] + i*b[y]):

1. I do not see a problem with the line that you indicated. The TypeError: non-boolean (Missing) used in boolean context occurs because of line 115 of your function: bn_complete[t] = ifelse(B_Emg[t] < BMIN | B_Emg[t] > 0, BMIN, B_Emg[t])

There is some operator precedence issues and issues with using missing. I believe this may be closer to what you intend.

You are initializing np.zeros((2,2)) in the while loop itself, so at every iteration you are creating a new 2D array. Just initialize np.zeros((2,2)) before the loop, and it will work.

1. The time complexity of this function based on its number of comparisons can be derived by "counting" how many comparisons are performed when calling the function on a list with N elements. There are two statements where you directly use comparisons here: len(list) == 1 and max1 > max2. There are clearly O(N) comparisons.
2. The time complexity of the function overall must take into account all the statements. So it will be at least equal to the previous complexity (therefore it can't be O(logN)). In this specific case, slicing operations do cost a lot. In general, the operation l[i1:i2] costs O(i2-i1). For more details, check out this question. So I would say that the total time complexity is O(N^2) in this case. If you want to improve the performance, you could pass the indexes instead of using slicing.