Engee 文档
Notebook

数据类型

Julia语言的类型系统是动态的，但同时也包含静态类型系统的一些优点，允许你指定某些值属于某些类型。

对象值和非对象值之间没有分离：Julia 中的所有值都是真正的对象，其类型属于一个完全连接的类型图，该类型图中的所有节点都是一等类型。

下面是Engee和MATLAB数据类型的比较汇总表。

| 类型（Engee/MATLAB） | 位数 | 最低值 | 最高值 | | 数据类型（Engee/MATLAB） | 位数 | 最低值 | 最高值 |--------------------------|----------------|----------------------|-----------------------| | Int8 / int8 | 8 | -2^7 | 2^7 - 1 | UInt8 / uInt8 | 8 | -2^7 | 2^7 - 1 | 2^7 - 1 |UInt8 / uint8 | 8 | 0 | 2^8 - 1 | | Int16 / int16 | 16 | 16 | -2^{15} | 2^{15} - 1 | |UInt16 / uint16 | 16 | 16 | 0 | 2^{16} - 1 | | Int32 / int32 | 32 | -2^{31} | 2^{31} - 1 | | UInt32 / uint32 | 32 | | 0 | 2^{32} - 1 | | Int64 / int64 | 64 | -2^{63} | 2^{63} - 1 | |UInt64 / uint64 | 64 | 0 | 0 | 2^{64} - 1 | | Int128 / no | 128 | -2^{127} | 2^{127} | 2^{127} - 1 | UInt128 / 否 | 128 | 0 | 2^{128} - 1 | | 2^{128} - 1 | Bool / 逻辑 | 8/1 | false(0) | true(1) | | | | 8/1 | Float16 / 无 | 16 | 半精度 | 半精度 | 半精度 | 半精度 | Float32 / single | 32 | Single | Single precision | Single precision | Single precision | Single precision | Single precision | Single precision | Float64 / double | 64 | Double precision | Double precision | (Nifj or Qifj). | (Nifj 或 Qifj) / fi(i,x,n,m) | (min 8, max 64) / (min 1, max 1024) | 固定点数值 | 固定点数值 | 固定点数值 | 固定点数值

类型声明

:: 操作符可用于为程序中的表达式和变量附加类型注释。这样做有两个主要原因。

1.作为一种设置，帮助确认程序是否按预期运行。 2.为编译器提供额外的类型信息，在某些情况下可以提高性能。

当:: 运算符被添加到一个求值表达式中时，它的读法是 "是......的实例"。

In [ ]: 
(1+2)::Int
Out[0]:
3

在赋值的左侧添加到变量时，:: 会声明变量始终具有指定的类型，类似于静态类型语言（如 C）中的类型声明。

In [ ]: 
function foo()
    x::Int8 = 100
end
Out[0]:
foo (generic function with 1 method)
In [ ]: 
x = foo()
Out[0]:
100
In [ ]: 
typeof(x)
Out[0]:
Int64

如果变量的某个赋值意外地改变了变量的类型，这一功能对于防止出现性能问题非常有用。

这种 "声明 "行为只出现在特定的上下文中，并适用于整个当前作用域，甚至在声明之前也是如此。

In [ ]: 
local x::Int8  # in a local declaration

类型声明也可以应用于全局变量。

In [ ]: 
a = 10
Out[0]:
10
In [ ]: 
typeof(a)
Out[0]:
Int64
In [ ]: 
function foo(y)
        global a = 15   # throws an error when foo is called
        return a + y
end
Out[0]:
foo (generic function with 2 methods)
In [ ]: 
foo(10)
Out[0]:
25

声明也可以附加到函数定义中：

In [ ]: 
function sinc(x)::Float64
    if x == 0
        return 1
    end
    return sin(pi*x)/(pi*x)
end

sinc(1.1)
Out[0]:
-0.08942105846213334

抽象类型

抽象类型无法创建，只能作为类型图中的节点，从而描述作为其后代的相关具体类型的集合。

In [ ]: 
abstract type Pointy{T} end
In [ ]: 
Pointy{Int64} <: Pointy
Out[0]:
true
In [ ]: 
Pointy{1} <: Pointy
Out[0]:
true
In [ ]: 
Pointy{Float64} <: Pointy{Real}
Out[0]:
false

车队类型

皮质是对函数参数的抽象，而不包含函数本身。函数参数最重要的方面是它们的顺序和类型。因此，元组类型类似于参数化的不可变类型，其中每个参数都是一个字段的类型。例如，包含两个元素的元组类型类似于下面的不可变类型：

In [ ]: 
struct Tuple2{A,B}
    a::A
    b::B
end

然而，它们有三个主要区别：

  1. 元组类型可以有任意数量的参数。 元组类型的参数是协变的：Tuple{Int} 是Tuple{Any} 的子类型。因此，Tuple{Any} 被视为抽象类型，而元组类型只有在其参数是具体的情况下才是具体的。 3.元组没有字段名；字段只能通过索引访问。

元组值用括号和逗号书写。在构造元组时，会根据需要生成相应的元组类型：

In [ ]: 
typeof((1,"foo",2.5))
Tuple{Int64, String, Float64}
Out[0]:
Tuple{Int64, String, Float64}
In [ ]: 
Tuple{Int,AbstractString} <: Tuple{Real,Any}
Out[0]:
true
In [ ]: 
Tuple{Int,AbstractString} <: Tuple{Real,Real}
Out[0]:
false

Vararg 元组类型

元组类型的最后一个参数可以是一个特殊值Vararg ，表示任意数量的有限元素：

In [ ]: 
mytupletype = Tuple{AbstractString,Vararg{Int}}
Tuple{AbstractString, Vararg{Int64}}
Out[0]:
Tuple{AbstractString, Vararg{Int64}}
In [ ]: 
isa(("1",1,2), mytupletype)
Out[0]:
true
In [ ]: 
isa(("1",1,2,3.0), mytupletype)
Out[0]:
false

已命名元组

已命名元组是NamedTuple 类型的实例，它有两个参数：一个字符元组指定字段名称，另一个元组类型指定字段类型。为方便起见，NamedTuple 类型使用@NamedTuple 宏呈现。

In [ ]: 
typeof((a=1,b="hello")) # prints in macro form
@NamedTuple{a::Int64, b::String}
Out[0]:
@NamedTuple{a::Int64, b::String}

参数原始类型

基元类型也可以按参数声明。例如，指针表示为基元类型，在 Julia 中的声明如下：

In [ ]: 
# 64-bit system:
primitive type P{T} 64 end
In [ ]: 
P{Int64} <: P
Out[0]:
true
In [ ]: 
P{Float64} <: P
Out[0]:
true

输出

本演示介绍了基本数据类型及其声明和使用方法。 更多信息请参阅有关 [整数和浮点数] 的文章(https://docs.julialang.org/en/v1/manual/integers-and-floating-point-numbers/#Integers-and-Floating-Point-Numbers)和有关 [数据类型] 的文章(https://docs.julialang.org/en/v1/manual/types/#man-types)，后者是本演示的基础。