4,240 karma · joined February 3, 2012
* Julia's arrays are column major but when you use spaces to write them, you do so in row major fashion. This new syntax enables a column major input: `[1 2; 3 4]` is equivalent to `[1; 3;; 2; 4]`.
* When you're using spaces, it might feel "funny" to jump from one semicolon (which concatenates the rows in the first dimension) to three semicolons (which concatenates the matrices in the third dimension) in an expression like `[1 2; 3 4;;; 5 6; 7 8]`, but the key is that spaces first build rows and then the semicolons concatenate them along a particular dimension.
Anyhow, if you can expand on what's causing trouble, it'd be great to figure out how to improve the description in the manual.
https://discourse.julialang.org/t/array-ordering-and-naive-s...
That's why finer-grained flags are needed — yes, FMAs and SIMD are essential for _both_ performance and improved accuracy, but `-ffast-math` bundles so many disparate things together it's impossible to understand what your code does.
> And most math will work fine with fast-math, if you are careful how you write it.
The most hair-pulling part about `-ffast-math` is that it will actively _disable_ your "careful code." You can't check for nans. You can't check for residuals. It'll rearrange those things on your behalf because it's faster that way.
* Included a graph of the resulting ordering of the two dimensional plane and some examples
* Included consideration of 5- or 10-star scales.
The trouble is exactly that it _can_ manifest early and it can become aggressive and that's when it's crucial to catch and treat.
> If you want a small report instead of a book with numbered sections, then Weave.jl might be more suitable for your problem.
And yes, the narrative of the story is definitely important, because it avoided all the rabble you see here that was getting in the way of a simple first step.
> I eventually asked them to humor me and just bring out the boxes for the various laptop models so I could see the boxes, which they did, despite clearly thinking that my decision making process made no sense
I don't know BGP well, but it seems easier for peers to just drop FB's packets on the floor than deal with a DNS stampede.
https://nbdime.readthedocs.io/en/latest/vcs.html#git-integra...
Julia Computing is a company founded by all of the co-creators of the Julia Language, and we've just raised our Series A to build out our core product: JuliaHub, a SaaS platform for computing (analysis, modeling, and simulation) at scale targeting many different technical domains. We're hiring for many full-time roles: https://jobs.juliacomputing.com/jobs
- Sales Engineer (Boston or Remote US): https://jobs.juliacomputing.com/jobs/y58-NbhWEM-e/
- Cloud Engineer (Bangalore, Boston, or Remote): https://jobs.juliacomputing.com/jobs/k_NT-998DQPl/
- Compiler and Runtime Engineer (Boston, or Remote): https://jobs.juliacomputing.com/jobs/4fc4leHHp9V_/
- Julia Application Developer: https://jobs.juliacomputing.com/jobs/3NhVYuObq6cY/
- Wireless Systems Research Engineer: https://jobs.juliacomputing.com/jobs/NpHiTgQMWv94/
Doing something like what you initially suggested would break that.
Now whether that's accurate to you depends upon your application. But the numbers don't care.
This is a common misconception: IEEE754 floating point arithmetic is not wrong or fuzzy or inherently inexact. It is very exact; it just has limited precision.
Your algorithm would give an answer that's a million values away.
I forgot a high-value item at a checkout lane the other day, and when I returned with my receipt to ask for it, they pulled up the video of the checkout lane to confirm I hadn't gotten it. Not terribly far-fetched to see that moving to identification via tracking to LPR or otherwise.
And sure enough, google finds a vendor that combines the two: https://www.asmag.com/showpost/9640.aspx
That's also why this only applies if connected to iCloud; otherwise they don't have "knowledge" of it.
Is that not the simpler explanation for this?
Now what I see frequently is that folks *do* regularly suggest workflows that work for them. Sometimes too zealously, yes. And indeed REPL-based workflows aren't for everyone.
On documentation I whole-heartedly agree. The manual hasn't seen a major re-structuring since its inception AFAIK — and it's long overdue.
Julia aggressively compiles multiple specialized versions of almost all the methods it encounters — one specialization for each unique combination of the argument types you pass. Even if you only define a single method `f(x,y) = 3x+2y`, Julia will compile a specialized floating point implementation when you call `f(2.5, 3.5)`, an integer implementation when you call `f(1, 2)`, and so on. It's this very aggressive compilation of everything many times over that makes Julia infamously slow to start and fast to run.
Inside each of these specializations, Julia concretely knows the type of `x` and `y`. And so it can — while compiling it — look up exactly which multiplication method it should use to compute `3x` and `2y`, inline them, infer the types of the results, lookup which `+` method to call, and inline it.
Even if you end up calling bigger functions that don't inline, Julia can hard-code the pointer to the exact specialization of every function you call because it's in a context where it knows the exact types of everything.
So it's a bit of a chicken-and-egg question. Julia's JIT (typically) compiles specializations of methods with precisely known argument types. This makes does make inference easier: every function call is a fresh start! If at any point inference loses the trail, it's ok, Julia just compiles it pessimistically to handle any type and can lookup the exact method/specialization that's needed for each function call on-demand (potentially compiling it and getting a new fresh start if needed), and then you're back on the happy well-inferred and super-specialized path.
help?> Complex
search: Complex complex ComplexF64 ComplexF32 ComplexF16 completecases
Complex{T<:Real} <: Number
Complex number type with real and imaginary part of type T.