It sounds like log-probability is the manifold surface area.
Distribution of potential over negative potential. Negative potential is the "surface area", and available potential distributes itself "geometrically". All this is iterative obviously, some periodicity set by universal speed limit.
It really doesn't sound like you disagree with me.
”The United States has threatened to stop financial aid to other countries if they trade non-food items with Cuba.”
"While the US measures against Cuba do not amount to a blockade in a technical or formal sense, their cumulative effect is to put an economic stranglehold on the island, which not only prevents the United States intercourse but also effectively blocks commerce with other states, their citizens and companies."
”Despite the existence of the embargo, Cuba can, and does, conduct international trade with many countries, including many US allies; however, US-based companies, and companies that do business with the US, which trade in Cuba do so at the risk of US sanctions.”
This is actually really easy. Most C/C++ code is pretty slow. Beating perfectly optimized C/C++ code by a notable margin is basically impossible (all relatively fast languages in the limit tend to converge to theoretical peak CPU performance), but real world code isn't perfectly optimized. The better question is on a performance vs effort graph who wins. Julia has a ton of major advantages here. The base language actually gives you fast implementations of common data structures (e.g. Dictionaries and BitSets) and BLAS/LAPACK wrappers to do linear algebra efficiently while still having your code look like math. The package manager makes it basically trivial to add packages for more complicated problems (no need to mess around with makefiles). the REPL makes it really easy to interactively tweak your algorithms and gives you easy ways to introspect the compilation process (@code_native and friends). Another major advantage is that Julia has macros that make it really easy to make local changes to a block of code's semantics that are compiler flags in C/C++. For example, consider `@fastmath`. In C/C++ you can only opt in to fastmath on a per-compilation unit level, so most projects that have one part that require IEEE handling of nonfinite numbers or require associativity in one part of the program will globally opt out of the non IEEE transforms. In julia, you just write `@fastmath` before a function (or for loop or single line) and you get the optimization.
All the other answers are true. But there is one thing I didn't see people saying. Thanks to the existence of macros, you can create->compile code in runtime. This allows for faster solving of some problems which are too dynamic, thanks to the fast compile times of Julia.
This might sound counterintuitive given that latency is a normal problem mentioned everywhere else about Julia. But, if you think about it, Julia compiled to native code a plot library from scratch in 15- seconds every time you imported it (before Julia 1.9 where native caching of code was introduced, and latency was cut down significantly).
This makes that problems where you would like to (for example) generate polynomials in runtime and evaluate then a billion times each, Julia can generate efficient code for ever polynomial, compile it and run it fast those billion times. C/C++/Fortran would have needed to write a (really fast) genetic function to evaluate polynomials, but this would have always (TM) been less efficient than code generated and optimised for them.
Edit: typos and added some remarks lacking originally
In general, parallelization was a messy kludge in older languages originally intended for single CPU machine contexts. Additionally, many modern languages inherited the same old library ecosystem issues with Simplified Wrapper and Interface Generator template code (Julia also offers similar support).
Only a few like Go ecosystem developers tended to take the time to refactor many useful core tools into clean parallelized versions in the native ecosystem, and to a lesser extent Julia devs seem to focus on similar goals due to the inherent ease of doing this correctly.
When one compares the complexity of a broadcast operator version of some function in Julia, and the amount of effort needed to achieve similar results in pure C/C++... the answer of where the efficiency gains arise should be self evident.
One could always embed a Julia programs inside a c wrapper if it makes you happier. =)
I do not dispute that C is not the fastest language. However C99 has the `restrict` keyword, which when combined with strict aliasing rules gives non-aliasing function arguments (I believe).
There are a few cases where it's easier to get LLVM to generate certain code I imagine. Semantic things like aliasing, in lining, and type information.
In general though it's just a question of which hoops you have to jump through for which language comparing C/C++/Julia/Fortran when using LLVM
There's room for a lot of these to grow and solve different problems. As I see the design space for those 2:
I like graph-tool for the variety of algs and CPU performance, focus on modeling, and will refer people to it when they outgrow nx/ix. However, it is (currently) not as approachable as others for example, which matters for social scientists who aren't devs, and for perf, we like cuGraph because both GPU/multi-GPU for the alg subset it does do, which is often 'enough'. Also, graph tool's licensing is not allowed by many of our users, while cugraph and easygraph's are. Generally, these libraries have viz but more just to check the box, and integrations to more dedicated tools improve that story.
These libraries take a lot of work, and both are impressive here. Something I look for is sustainability - will it outlive the life of a grad student or postdoc primary contributor getting their next job, or a professor's interests naturally shifting, or a startup if their next funding round doesn't happen / evilCorp acquihires them. This is extra poignant with redisgraph shutting down. A good tell is if it has been around X years, good chance it'll be around X/2 more, something like that. Very few at that level in the graph world!
graph-tool is LGPL, which means it can be used as a library even in proprietary code. So I don't know how it could not be allowed for your users.
The python API is almost identical to 'EasyGraph'. I'm curious why you consider it less approachable.
graph-tool visualization is killer. Not an after-thought to check a box. You can do animations, visualize interactively (move node positions with the mouse), generate publication-quality SVG/PNG/PDF seamlessly, integrate with other applications using GTK, cairo, etc.
It has been around since 2006, and is maintained by an academic group.
We see many non-academic users (startups, enterprises, gov, ...) where it is common to only allow licenses like Apache, MIT, & BSD for libraries, so LGPL often makes sw not even a contender
Like I said, I'm a fan and refer folks to it when fits. Other libraries focus on strengths like licensing, viz, perf, AI, ease, etc that graph-tool doesn't invest as much in. Ex: competing with Nvidia on GPU computing is doable, but takes a special kind of focus - it's not an accident we have been working with them for years. Graph-tool is strong in general, just not everything to everyone.
It seems entirely nonsensical not to allow LGPL for library code, since it does not add any restrictions compared to BSD/MIT/etc. You should advise your users better in this regard, since they seem to not understand how these licenses work.
LGPL is understood to incur stipulations in scenarios like static linking, which for a dev library, can be a concern. These concerns are not in MIT/BSD/Apache, which is why professional organizations often have rules allowing only the latter. It takes undesirable work by developers to go against their organizational guidelines.
My job isn't to advise users on legal matters nor promote graph-tool, though I do try to increase awareness of options in general as a neutral technical party. The graph-tool's community's decision to use & stick to a relatively unpopular license (outside of academia), and the ensuing issues around legal, practical, and perception... are problems for the graph-tool community to address, not me.
We OSS our work as MIT/BSD/Apache because that's what our users accept and pay us to do. That's all that's in our control.
I'm confused. There was a surprise that LGPL was not seen as equiv as MIT/BSD/Apache by orgs, so I clarified with the typical example of why organizations may have default-deny rules for LGPL libraries bc the static linking restrictions, and that those default-deny rules would require devs in these orgs to get an exception. You made me curious, and this thread was enlightening to me: https://www.quora.com/Can-I-use-LGPL-in-commercial-software . Note the political & bureaucratic work that'd be involved to get a licensing exception, and then the extra SW infra work to do the above.
Again, I try to keep our team technical & neutral about graph DB/lib/etc providers. We get used with a variety of tools, and I personally end up seeing areas where each invests more than others + try to keep discussions to the resulting kind of objective distinction. So I'm genuinely curious what's wrong in my summary, both wrt legal theory and what organizations do in practice. I get frustrated when projects we get pulled into (digital crime, outages, genomics, ...) get hamstrung by something like OSS licensing.
Entropy is not a "distribution”, it's a functional that maps a probability distribution to a scalar value, i.e. a single number.
It's the mean log-probability of a distribution.
It's an elementary statistical concept, independent of physical concepts like “pressure”, “potential”, and so on.