talks | : book : Collection of my AI-related Talks | Machine Learning library

I'd suggest that running .bat, the set is leaving errorlevel unchanged, but this has been "corrected" for .cmd to setting errorlevel to 0 as the set succeeded.

To directly answer your question, without further elaboration about how to break ties, two different implementations of Shannon-Fano could produce different codes of different lengths for the same inputs.

As @MattTimmermans noted in the comments, Shannon-Fano does not always produce optimal prefix-free codings the way that, say, Huffman coding does. It might therefore be helpful to think of it less as an algorithm and more of a heuristic - something that likely will produce a good code but isn't guaranteed to give an optimal solution. Many heuristics suffer from similar issues, where minor tweaks in the input or how ties are broken could result in different results. A good example of this is the greedy coloring algorithm for finding vertex colorings of graphs. The linked Wikipedia article includes an example in which changing the order in which nodes are visited by the same basic algorithm yields wildly different results.

Even algorithms that produce optimal results, however, can sometimes produce different optimal results based on tiebreaks. Take Huffman coding, for example, which works by repeatedly finding the two lowest-weight trees assembled so far and merging them together. In the event that there are three or more trees at some intermediary step that are all tied for the same weight, different implementations of Huffman coding could produce different prefix-free codes based on which two they join together. The resulting trees would all be equally "good," though, in that they'd all produce outputs of the same length. (That's largely because, unlike Shannon-Fano, Huffman coding is guaranteed to produce an optimal encoding.)

That being said, it's easy to adjust Shannon-Fano so that it always produces a consistent result. For example, you could say "in the event of a tie, choose the partition that puts fewer items into the top group," at which point you would always consistently produce the same coding. It wouldn't necessarily be an optimal encoding, but, then again, since Shannon-Fano was never guaranteed to do so, this is probably not a major concern.

If, on the other hand, you're interested in the question of "when Shannon-Fano has to break a tie, how do I decide how to break the tie to produce the optimal solution?," then I'm not sure of a way to do this other than recursively trying both options and seeing which one is better, which in the worst case leads to exponentially-slow runtimes. But perhaps someone else here can find a way to do that>

There is no exact equivalent. As noted, seq doesn't work because the by argument is automatically set with the correct sign, and generates an error if you try to explicitly pass a positive sign when to < from. Just create a very simple wrapper if you need to have the exact match.

After a lot of digging, I've found the ::theme selector was a proposal which didn't get implemented
Although mentioned here https://developer.mozilla.org/en-US/docs/Web/CSS/::part at the bottom under "See also". I then found this explainer issue that was closed, confirming that the ::theme did not make the cut https://github.com/fergald/docs/issues/4
The ::theme selector is therefor also not in the docs of CSS Shadow parts as of the CSS W3C Editors draft from 15th September 2020, see it below:
https://drafts.csswg.org/css-shadow-parts/

I don't know if anyone will pick up the torch and implement this pseudo selector, but i surely do hope so, as i would see it frequently used, at least in my needs.

Hope this question and answer will help someone else out and not spend tons of time going down this rabbit-hole :)

I suggest using atomic groups (?>...), please see regex tutorial for details

After erasure, the getStringArr should return Object[], and it is able to cast to String[] without any problem.

Return type of the getStrArr, after type erasure, would be Object[] but, in your code, it is returning arr which is of type String[]. That is why there is not ClassCastException in your code.

Consider the following method (suppose generic arrays were allowed):

It is not possible

Note: crates.io does not allow packages to be published with path dependencies (path dev-dependencies are ignored). See the Multiple locations section for a fallback alternative.

It is possible to specify both a registry version and a git or path location. The git or path dependency will be used locally (in which case the version is checked against the local copy), and when published to a registry like crates.io, it will use the registry version. Other combinations are not allowed.

You will need to have the dependency uploaded to crates.io.

The rules of constraint expression normalization act recursively top-down. If an expression is not a conjunction/disjunction of two expressions, is not a parenthesized expression, and is not a concept name, then it is an atomic constraint expression. A requires expression is not one of those exceptions, so it is an atomic constraint expression.

• Loose objects - are those that aren't packed. Git can compress many loose objects into a single pack file.
• Dangling object - is the one that's not referenced by anything (e.g. an orphan commit which has no branch/tag pointing to it). It's garbage that will at some point be collected by GC.
• "Unreachable" object (see comment by @torek). If commit A is a parent of B, then A is not dangling even if B is. Instead A is "unreachable". It's also part of garbage.

Loose object can be dangling, packs can contain dangling objects. So these concepts are orthogonal. But you can create a reference (branch, tag) which will reference a dangling commit and it will stop "dangle".