NLog | Flexible logging for C # and Unity

Here are several options:

Create the logger inside every module function

In this expression:

The nlog config file should be carefully located so your resulting build project files load it correctly. In the documentation about the File Location info you see where the programs looks for the Nlog config file.

You can indeed include it in your project and set the property Copy to Output directory to Copy if newer

As logging is inherently impure there isn't a particularly clean way to do logging that I'm aware of. You have basically identified the two solutions in your question. Which one you use depends on what the logs are being used for.

For logging to external services I would consider creating an AppContext type which is home to app and user settings as well as providing functions or methods for logging to e.g. a database. This type should be added an extra parameter in your functions or an additional field in your types depending on what makes the most sense.

For your lowest-level functions rather than changing them all to accept an additional parameter you should consider altering the return type to include the information you want to log and leaving the act of logging to higher level parts of your program.

For logging to a console, rolling buffer, or other temporary location I think it is fine to create a module which is equivalent to a C# static class and just provide globally accessible logging functions.

I was intrigued by this problem in part because, as I indicated in the comments, I felt certain that it could be done in O(n) time. I had some time over this past weekend, so I wrote up my solution to this problem.

This means that whenever you add a number to the collection, if the number added was not already one of the mode-values then the frequency of the mode would not change. So with the collection (8 9 9) the mode-values are {9} and the mode-frequency is 2. If you add say a 5 to this collection ((8 9 9 5)) neither the mode-frequency nor the mode-values change. If instead you add an 8 to the collection ((8 9 9 8)) then the mode-values change to {9, 8} but the mode-frequency is still unchanged at 2. Finally, if you instead added a 9 to the collection ((8 9 9 9)), now the mode-frequency goes up by one.

Thus in all cases when you add a single number to the collection, the mode-frequency is either unchanged or goes up by only one. Likewise, when you remove a single number from the collection, the mode-frequency is either unchanged or goes down by at most one. So all incremental changes to the collection result in only two possible new mode-frequencies. This means that if we had all of the distinct numbers of the collection indexed by their frequencies, then we could always find the new Mode in a constant amount of time (i.e., O(1)).

To accomplish this I use a custom data structure ("ModeTracker") that has a multiset ("numFreqs") to store the distinct numbers of the collection along with their current frequency in the collection. This is implemented with a Dictionary (I think that this is a Map in Java). Thus given a number, we can use this to find its current frequency within the collection in O(1).

This data structure also has an array of sets ("freqNums") that given a specific frequency will return all of the numbers that have that frequency in the current collection.

I have included the code for this data structure class below. Not that this is implemented in C# as I do not know Java well enough to implement it there, but I believe that a Java programmer should have no trouble translating it.

Let's say you have an element x and an array of distinct elements, A = [x0, x1, ..., x_{k-1}] and want to know if the x is equivalent to some element in the array and if yes, to which element.

What you can do is a simple recursion (let's call it check-eq):

• Check if query([x, A]) == k + 1. If yes, then you know that x is distinct from every element in A.
• Otherwise, you know that x is equivalent to some element of A. Let A1 = A[:k/2], A2 = A[k/2+1:]. If query([x, A1]) == len(A1), then you know that x is equivalent to some element in A1, so recurse in A1. Otherwise recurse in A2.

This recursion takes at most O(logk) steps. Now, let our initial array be T = [x0, x1, ..., x_{n-1}]. A will be an array of "representative" of the groups of elements. What you do is first take A = [x0] and x = x1. Now use check-eq to see if x1 is in the same group as x0. If no, then let A = [x0, x1]. Otherwise do nothing. Proceed with x = x2. You can see how it goes.

Complexity is of course O(nlogn), because check-eq is called exactly n-1 times and each call take O(logn) time.

There is not going to be an O(N) algorithm for the problem as written. Given a function that solves this problem, you could use it to partition N/2 arbitrary numbers into N/2 arbitrary adjacent ranges.

For example [2532,1463,3264,200,4000,3000,2000,1000] produces [5,6,4,7,-1,-1,-1,-1], identifying the ranges of the first N/2 numbers.

If you can only relate the numbers by comparison, then this will take you N/2 * log(N/2) comparisons, so O(N log N) time.

Without a limit on the size of the numbers, which would let you cheat like a radix sort, there isn't going to be way that is asymptotically faster than all comparison-based methods.

The complexity of your function f, for arr of size n. We'll assume:

Thanks to all who helped. I figured it out and hopefully this can help anyone who runs into a similar problem. The issue I had was I incorrectly assigned the coefficients for a_coeffs and b_coeffs.

Here is the solution which passed the tests for those interested.