Julia语言入门：计算科学与编程实践

Julia

需积分: 15 130 浏览量更新于2023-05-14 收藏 906KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

资源详情

资源推荐

Introduction to Computational Physics Gerson J. Ferreira - INFIS - UFU - Brazil

1.2.3 Other interfaces

During the classes we will use mostly the command line interface and scripts. Therefore

I will not cover here a guide to use the other possible interfaces: JuliaBox, Juno IDE, and

iJulia. These are easy-to-use interfaces, so after learning about the command line and

scripts, you will probably have no difﬁcult using the others.

1.3 Constants and variable types

Julia comes with a few predeﬁned mathematical constants:

• π = pi = 3.1415926535897...;

• e = e or eu = 2.7182818284590..., Euler’s number, base for the natural logarithm;

•

For complex numbers, use

for the imaginary part. For example:

z = 5 + 3im

;

• True and false constants are true=1, and false=0;

The variable types in Julia are dynamic. This means that you don’t have to declare it

beforehand. For instance:

Example 1.11: Variable types

julia> a = 8

julia> typeof(a) # will tell you that "a" is 64bit integer

julia> sizeof(a) # used memory in bits

julia> a = 8.0

julia> typeof(a) # now "a" is a 64bit floating-point number

julia> sizeof(a)

julia> a = 8.0 + 3.0im

julia> typeof(a) # is a complex floating-point number

julia> sizeof(a)

julia> a = 8 + 3im

julia> typeof(a) # is an integer floating-point number

julia> sizeof(a)

julia> a = true

julia> typeof(a) # is a Boolean

julia> sizeof(a)

The difference between the types is how the variable is stored in memory. A ﬂoating-

point number is the computer version of the Real numbers

Float64

means that Julia

is using the double precision format (64 bits), which uses one bit for the sign, 11 bits for

the exponent, and 52 bits for the fraction. Since 1 byte = 8 bits, each

Float64

variable

will need 8 bytes memory. For instance, if you have a 100

100 real matrix, there will

For more details, check Wikipedia’s entry on the double precision (64bits) ﬂoating-point num-

bers:

https://en.wikipedia.org/wiki/Double-precision_floating-point_format

, and a gen-

eral discussion on ﬂoating-point numbers https://en.wikipedia.org/wiki/Floating_point.

Introduction to the Julia language

be 100

Float64

numbers to store, consuming 80.000 bytes = 80 kB. You can check the

memory use of any variable with the command

sizeof(...)

. Evidently, a 64 bit integer,

e.g. Julia’s

Int64

, also needs 8 bytes of memory. So, what’s the advantage of having both

Float64 and Int64 types of variables? I’ll leave this to you as a problem.

Note that the complex variable takes twice the memory of a real or integer variable.

It has to store both the real and imaginary part. Boolean variables uses only a single bit!

Since it can be only true or false, a single bit sufﬁces.

1.3.1 Assertion and Function Overloading

Type assertion is particularly useful when deﬁning functions. It can be used to assure

that the functions receives an argument of a certain type. For instance, let’s deﬁne a

function that calculates the factorial using a loop:

Example 1.12: Factorial function with assertion

function fact(n::Int64)

res = 1; # initialize the result as 1

for i=n:-1:1 # loop the variable i from N to 1 in steps of -1

res = res*i; # since n! =n ·(n −1)·(n −2)···(1)

end # end loop

return res; # return the result

end

In the ﬁrst line the argument of the function

fact(n::Int64)

is declared as an

Int64

If you try to call this function as

fact(4)

, you will get the correct result, 24. But if you

call fact(4.0), it fails. The function is not deﬁned for an arbitrary argument.

If you have a function that for different types of parameters may take different

forms, you can use

function overloading

. This is an extremely useful feature of modern

computer languages. For instance, the factorial of a real number can be deﬁned via the

Riemann’s Γ function,

Γ(n) =(n −1)!, for n ∈Z

, (1.1)

Γ(t ) =

∞

t−1

−x

d x, for t ∈R. (1.2)

We, humans, use the same letter

for these functions. But the expression used to

calculate the result depends on the parameter being integer or real. Function overload-

ing is the computer language way of making the decision between the two forms of

above. Check the next example.

Introduction to the Julia language

In the example above we have deﬁned a new type of variable (

Particle

), and we

create two variables of this type representing particles

and

. The parameters (posi-

tion and momenta) are the “ﬁelds” of this new variable type. The parameters passed to

these variables when deﬁning

and

are called the “initialization”. Once the variables

exist, you can access and modify its contents using the construct

variable.field

, as

in the example where we update the position of particle q

This is a silly example, but eventually we will use this to help us solve the motion of

planets using Newtonian dynamics.

Instead of the declaring the composite type using the

type

keyword, you could

also work with the

immutable

, i.e.

immutable Particle ··· end

. Immutable types work

as constants, they cannot be modiﬁed. The main difference between “mutable” and

immutable types is that the ﬁrst is passed by reference to a function, while the second is

passed by copy

1.3.3 Tuples

In mathematics, a tuple is a ordered list of elements. For instance, a vector

can

be written as 3-tuple: (

x, y, z

). Julia’s documentation describes this type of data as an

abstraction of the arguments of a function.

Example 1.15: Tuples: square root

function squareroot(x::Number)

return (+sqrt(x), -sqrt(x)) # returns a tuple

end

sols = squareroot(9);

println("The square roots are ", sols[1], " and ", sols[2]);

println("The number of square roots is ", length(sols));

sols[1] = 0; # will return an error

In the example above, while the

sqrt(···)

native command returns only the positive

square root, our example function returns a tuple with all square roots. The tuple is

stored in the variable

sols

, and each value can be accessed via the construct

sols[1]

sols[2]

··· sols[i] ··· sols[n]

, where the number of elements in the tuple can be

checked with the

length

command. In the simple example above, we will always have

two entries in the tuple. However, some codes may return a tuple of an arbitrary number

of entries. In this case you may use the command

length

to check the number of

elements.

In Julia, a tuple is an immutable type: you cannot change its contents, and it will be

passed to a function by copy. Therefore tuples are appropriated when you need to pass

If you are a beginner, you probably don’t know what “passing by reference/copy” means. Don’t

worry, we’ll get to that.

Introduction to Computational Physics Gerson J. Ferreira - INFIS - UFU - Brazil

vector or matrix parameters by copy, instead of by reference. Apart from this, they are

equivalent to arrays.

1.3.4 Arrays: vectors and matrices

As we have seen above, mathematically and array is a tuple. In Julia an array is a mutable

tuple. To distinguish these two, tuples are deﬁned by parenthesis as

pos = (x,y)

, while

arrays are set by square brackets as

pos = [x, y]

. Essentially, both tuples and arrays

could be used to represent vectors and matrices. However, when we are working with

vectors and matrices, we will probably need to update their values along the calculation.

Therefore we need a mutable type: the array.

Let’s deﬁne a vector and a matrices and try some common operations.

Example 1.16: Arrays: vectors and matrices

veclin = [1 2 3] # this is a line vector (1 ×3)

veccol = [1; 2; 3] # this is a column vector (3 ×1)

matA = [4 5 6; 7 8 9; 10 11 12] # a 3 ×3 matrix

matB = [3 2 1; 6 5 4; 9 8 7] # another 3 ×3 matrix

matA*veccol # (3 ×3) ·(3 ×1) =(3 ×1)

veclin.’ # transpose the vector

veccol’ # conjugate transpose the vector

matA’ # conjugate transpose the matrix

inv(matA) # calculates the inverse

matA*matB # mathematical product of the matrices

matA.*matB # direct element by element product

Run the example above line by line and check the outputs to understand what

each command does. You will see that there’s no difference between the conjugate and

the transpose conjugate here, because we are dealing with real values. Try deﬁning a

complex matrix or vector and check again the difference between these two commands.

There’s a lot more you can do with vectors and matrices of course. We’ll learn

more tricks as we go along. For instance, a nice trick to construct matrices is the

comprehension

construct that we present in Section 1.4.5. Other relevant commands

that we may use later on are:

• zeros(n): creates an array of zeros with n elements;

• zeros(n,p): creates a n ×p matrix with all elements set to zero;

• ones(n), and ones(n,p): equivalent to zeros, but all elements are set to 1;

剩余98页未读，继续阅读

CompTech

粉丝: 9
资源: 2

会员权益专享

Julia语言入门：计算科学与编程实践

Julia程序设计

julia语言文档 pdf版本

julia_code_examples：Julia编程语言的代码示例（面向初学者）

julia语言怎么样啊？

用julia语言写一个时间序列程序

介绍一下julia genie

Julia代码编程

julia详细使用OpenAI的详细代码实例。

jupyter程序编写

用julia写一个波动率交易程序

jupyter网页能直接用吗

jupyter notebook背景

Jupyter notebook安装

jupyter php

jupyter notebook是什么

ipadJupyter lua

jupter notebook软件介绍

jupyter notebook 原理

jupyter notebook

人工智能数据分析jupyter

会员权益专享

最新资源