T-Pot | Honeypot | SSH library

As per @MrFlick 's comment, the typo was the problem: In the definition of reactive -> Recipe_Inv_Flt() the following if statement condition:

Several things are weird here.

Typically, you'll want to make your Generic classes take types of kind Type -> Type or k -> Type, and not to worry about the p parameter unless you need to deal with Generic1. So I'd expect something more like

Two things I noticed after a quick look where you can definitely save some time. Both require some more thinking before, but afterwards you will be rewarded with an optimised and cleaner code.

1. Try to avoid using append. append is highly inefficient. You start with an empty array, and afterwards need to allocate more memory each time. This leads to inefficient memory handling, as you copy your array each time you append a number. The longer the array gets, the more inefficient append becomes.

Alternative: Use np.zeros((m,n)) to initialise the array, with m and n being the size it will end up with. Then you need a counter that puts the new values in the corresponding places. If the size of the array is not defined before your calculation, you can initialise it as a big number, and afterwards cut it.

2. Try to avoid using for loops. They are generally very slow, especially when iterating through large matrices, as you need to index each entry individually.

Alternative: Matrix operations are generally much faster. For example, instead of r = np.sqrt(sum((matposg[j,:]-matposg[k,:])**2)) inside two for loops, you could first define two matrices A and B that correspond to matposg[j,:] and matposg[k,:] (should be possible without the use of loops!) and then simply use r = np.linalg.norm(A-B)

As mentioned in the comments, operator /, just like for + - *, forces its two operands to have the same type (and that's also the type of the result). Operator ^ is an exception, and its result has to have the same type as its left operand. Note that for floating-point types, you also have the ** exponentiation operator à la Fortran.

Rules are explained in more detail in this tutorial.

Unfortunately that means that mixed-mode arithmetics is somewhat less easy to get in Haskell than in some well-known imperative languages. If need be, conversion function fromIntegral :: (Integral a, Num b) => a -> b can be used. It gives the compiler license to insert some appropriate conversion.

For the present situation, if a broad type signature is desired, it can be achieved for example like this:

As @Willem Van Onsem noted, the two members of the tupes in l are the result of (/), whose type is Fractional a => a -> a -> a, because it requires both it's operands to be the same type, which also determines the result.

The solution to ambiguity is to be specific - specify what the types are that the compiler tells you could be one of many types:

There are several issues here:

• In Vega-Lite, timestamps are expressed in milliseconds, not seconds
• You are filtering on equality between a numerical timestamp and a string representation of a date.
• Even if you parse the date in the filter expression, Python date parsing and Javascript date parsing behave differently and the results will generally not match. Even within javascript, the date parsing behavior can vary from browser to browser; all this means that filtering on equality of a Python and Javascript timestamp is generally problematic
• The data you are using has monthly timestamps, so the slider step should account for this

Keeping all that in mind, the best course would probably be to adjust the slider values and filter on matching year and month, rather than trying to achieve equality in the exact timestamp. The result looks like this:

You should make use of foldl1, or provide the initial value for the accumulator. foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b expects an initial value as accumulator of type b. With foldl1 :: Foldable t => (a -> a -> a) -> t a -> a, it takes the first element as initial accumulator:

Computing logarithms is an inefficient way to find the value. Instead, work your way down the "tree", and compute the index on the way back up. This requires only an Integral constraint on the argument, since you never do anything except divide it by 2.

Note that all even indices evaluate to 2; the odd ones are computed recursively.