## Julia – 116 – differenze rispetto altri linguaggi – Octave Continuo da qui, copio qui.

Il manuale parla di MATLAB (e non correggerò) ma io uso Octave che, tranne per qualche particolarità molto specifica, è intercambiabile. E FOSS 😁

Although MATLAB users may find Julia’s syntax familiar, Julia is not a MATLAB clone. There are major syntactic and functional differences. The following are some noteworthy differences that may trip up Julia users accustomed to MATLAB.

Julia arrays are indexed with square brackets, `A[i,j]`.

Julia arrays are assigned by reference. After `A=B`, changing elements of `B` will modify `A` as well.

Julia values are passed and assigned by reference. If a function modifies an array, the changes will be visible in the caller.

Julia does not automatically grow arrays in an assignment statement. Whereas in MATLAB `a(4) = 3.2` can create the array `a = [0 0 0 3.2]` and `a(5) = 7` can grow it into `a = [0 0 0 3.2 7]`, the corresponding Julia statement `a = 7` throws an error if the length of a is less than 5 or if this statement is the first use of the identifier `a`. Julia has `push!()` and `append!()`, which grow `Vectors` much more efficiently than MATLAB’s `a(end+1) = val`.

The imaginary unit `sqrt(-1)` is represented in Julia as `im`, not `i` or `j` as in MATLAB.

In Julia, literal numbers without a decimal point (such as 42) create integers instead of floating point numbers. Arbitrarily large integer literals are supported. As a result, some operations such as `2^-1` will throw a domain error as the result is not an integer (see the FAQ entry on domain errors for details).

In Julia, multiple values are returned and assigned as tuples, e.g. `(a, b) = (1, 2)` or `a, b = 1, 2`. MATLAB’s `nargout`, which is often used in MATLAB to do optional work based on the number of returned values, does not exist in Julia. Instead, users can use optional and keyword arguments to achieve similar capabilities.

Julia has true one-dimensional arrays. Column vectors are of size `N`, not `Nx1`. For example, `rand(N)` makes a 1-dimensional array.

In Julia, `[x,y,z]` will always construct a 3-element array containing `x`, `y` and `z`.
To concatenate in the first (“vertical”) dimension use either `vcat(x,y,z)` or separate with semicolons (`[x; y; z]`).
To concatenate in the second (“horizontal”) dimension use either `hcat(x,y,z)` or separate with spaces (`[x y z]`).
To construct block matrices (concatenating in the first two dimensions), use either `hvcat()` or combine spaces and semicolons (`[a b; c d]`).

In Julia, `a:b` and `a:b:c` construct `Range` objects. To construct a full vector like in MATLAB, use `collect(a:b)`. Generally, there is no need to call `collect` though. `Range` will act like a normal array in most cases but is more efficient because it lazily computes its values. This pattern of creating specialized objects instead of full arrays is used frequently, and is also seen in functions such as `linspace`, or with iterators such as `enumerate`, and `zip`. The special objects can mostly be used as if they were normal arrays.

Functions in Julia return values from their last expression or the `return` keyword instead of listing the names of variables to return in the function definition.

A Julia script may contain any number of functions, and all definitions will be externally visible when the file is loaded. Function definitions can be loaded from files outside the current working directory.

In Julia, reductions such as `sum()`, `prod()`, and `max()` are performed over every element of an array when called with a single argument, as in `sum(A)`, even if `A` has more than one dimension.

In Julia, functions such as `sort()` that operate column-wise by default `(sort(A)` is equivalent to `sort(A,1)`) do not have special behavior for 1xN arrays; the argument is returned unmodified since it still performs `sort(A,1)`. To sort a 1xN matrix like a vector, use `sort(A,2)`.

In Julia, if `A` is a 2-dimensional array, `fft(A)` computes a 2D FFT. In particular, it is not equivalent to `fft(A,1)`, which computes a 1D FFT acting column-wise.

In Julia, parentheses must be used to call a function with zero arguments, like in `tic()` and `toc()`.

Julia discourages the used of semicolons to end statements. The results of statements are not automatically printed (except at the interactive prompt), and lines of code do not need to end with semicolons. `println()` or `@printf()` can be used to print specific output.

In Julia, if `A` and `B` are arrays, logical comparison operations like `A == B` do not return an array of booleans. Instead, use `A .== B`, and similarly for the other boolean operators like `<`, `>` and `=`.

In Julia, the operators `&`, `|`, and `⊻` (`xor`) perform the bitwise operations equivalent to `and`, `or`, and `xor` respectively in MATLAB, and have precedence similar to Python’s bitwise operators (unlike C). They can operate on scalars or element-wise across arrays and can be used to combine logical arrays, but note the difference in order of operations: parentheses may be required (e.g., to select elements of `A` equal to 1 or 2 use `(A .== 1) | (A .== 2)`).
Unicode per -> 8891 | 0x22bb.

In Julia, the elements of a collection can be passed as arguments to a function using the splat operator `...`, as in `xs=[1,2]; f(xs...)`.

Julia’s `svd()` returns singular values as a vector instead of as a dense diagonal matrix.

In Julia, `...` is not used to continue lines of code. Instead, incomplete expressions automatically continue onto the next line.

In both Julia and MATLAB, the variable `ans` is set to the value of the last expression issued in an interactive session. In Julia, unlike MATLAB, `ans` is not set when Julia code is run in non-interactive mode.

Julia’s types do not support dynamically adding fields at runtime, unlike MATLAB’s classes. Instead, use a `Dict`.

In Julia each module has its own global scope/namespace, whereas in MATLAB there is just one global scope.

In MATLAB, an idiomatic way to remove unwanted values is to use logical indexing, like in the expression `x(x>3)` or in the statement `x(x>3) = []` to modify `x` in-place. In contrast, Julia provides the higher order functions `filter()` and `filter!()`, allowing users to write `filter(z->z>3, x)` and `filter!(z->z>3, x)` as alternatives to the corresponding transliterations `x[x.>3]` and `x = x[x.>3]`. Using `filter!()` reduces the use of temporary arrays.

The analogue of extracting (or “dereferencing”) all elements of a cell array, e.g. in `vertcat(A{:})` in MATLAB, is written using the splat operator in Julia, e.g. as `vcat(A...)`.

C’è da aggiungere che oltre alla REPL Octave ha un’ottima IDE. 🤢

Posta un commento o usa questo indirizzo per il trackback.