Data is stored in values such as1, 3.14, and "Julia", and every other value has a type, for example, the type of 3.14 isFloat64. Some other examples of elementary values and their data types are 42 of the Int64 type, true and false of the Bool type, and 'X' of the Char type.

Julia, unlike many modern programming languages, differentiates between single characters and strings. Strings can contain any number of characters, and are specified using double quotes—single quotes are only used for a character literal. Variables are the names that are bound to values by assignments, such asx = 42. They have the type of the value they contain (or reference); this type is given by the typeof function. For example, typeof(x) returns Int64.

The type of a variable can change, because putting x = "I am Julia" now results in typeof(x) returning String. In Julia, we don't have to declare a variable (that indicates its type) such as in C or Java, for instance, but...

Julia's type system is unique. Julia behaves as a dynamically typed language (such as Python, for instance) most of the time. This means that a variable bound to an integer at one point might later be bound to a string. For example, consider the following:

julia> x = 1010julia> x = "hello""hello"

However, one can, optionally, add type information to a variable. This causes the variable to only accept values that match that specific type. This is done through a type of annotation. For instance, declaring x::String implies that only strings can be bound to x; in general, it looks like var::TypeName. These are used the most often to qualify the arguments a function can take. The extra type information is useful for documenting the code, and often allows the JIT compiler to generate better-optimized native code. It also allows the development environments to give more support, and code tools such as a linter that can check your code for possible wrong type use.

Here is an example: a...

Julia offers support for integer numbers ranging from types Int8 to Int128, with 8 to 128 representing the number of bits used, and with unsigned variants with a U prefix, such as UInt8. The default type (which can also be used as Int) is Int32 or Int64, depending on the target machine architecture. The bit width is given by the Sys.WORD_SIZE variable. The number of bits used by the integer affects the maximum and minimum value this integer can have. The minimum and maximum values are given by the typemin() and typemax() functions, respectively; for example, typemax(Int16) returns 32767.

If you try to store a number larger than that allowed by typemax, overflow occurs. For example, note the following:

julia> typemax(Int)9223372036854775807 # might be different on 32 bit platformjulia> ans + 1-9223372036854775808

Overflow checking is not automatic, so an explicit check (for example, the result has the wrong sign) is needed when this can occur. Integers can also be written in binary...

Floating point numbers follow the IEEE 754 standard and represent numbers with a decimal point, such as 3.14, or an exponent notation, such as 4e-14, and come in the types Float16 up to Float64, the last one being used for double precision.

Single precision is achieved through the use of the Float32 type. Single precision float literals must be written in scientific notation, such as 3.14f0, but with f, where one normally uses e. That is, 2.5f2 indicates 2.5*10^2 with single precision, while 2.5e2 indicates 2.5*10^2 in double precision. Julia also has a BigFloat type for arbitrary-precision floating numbers computations.

A built-in type promotion system takes care of all the numeric types that can work together seamlessly, so that there is no explicit conversion needed. Special values exist: Inf and -Inf are used for infinity, and NaN is used for "not a number" values such as the result of 0/0 or Inf - Inf.

Floating point arithmetic in all programming languages is often...

You can view the binary representation of any number (integer or float) with the bitstring function, for example, bitstring(3) returns "0000000000000000000000000000000000000000000000000000000000000011".

To round a number, use the round() function which returns a floating point number. All standard mathematical functions are provided, such as sqrt(), cbrt(), exp(), log(), sin(), cos(), tan(), erf() (the error function), and many more (refer to the URL mentioned at the end of this section). To generate a random number, use rand().

Use parentheses ( ) around expressions to enforce precedence. Chained assignments, such as a = b = c = d = 1, are allowed. The assignments are evaluated right-to-left. Assignments for different variables can be combined, as shown in the following example:

  a = 1; b = 2; c = 3; d = 4  a, b = c, d

Now, a has a value of 3 and b has a value of 4. In particular, this makes an easy swap possible:

  a, b = b, a   # now a is...

Julia supports these types out of the box. The global constantim represents the square root of -1, so that 3.2 + 7.1im is a complex number with floating point coefficients, so it is of the type Complex{Float64}.

This is the first example of a parametric type in Julia. For this example, we can write this asComplex{T}, where type T can take a number of different type values, such as Int32, Int64, or Float64.

All operations and elementary functions, such as exp(), sqrt(), sinh(), real(), imag(), abs(), and so on, are also defined on complex numbers; for example, abs(3.2 + 7.1im)= 7.787810988975015.

If a and b are two variables that contain a number, use complex(a,b) to form a complex number with them. Rational numbers are useful when you want to work with exact ratios of integers, for example, 3//4, which is of type Rational{Int64}.

Again, comparisons and standard operations are defined: float() converts to a floating point number, and num() and den() gives the numerator...