From 3eb6675cf2ed3889f4f1560f939a24ca9ead1aa3 Mon Sep 17 00:00:00 2001 From: kyujin0329 Date: Thu, 23 Nov 2017 23:28:06 +0900 Subject: [PATCH 1/4] =?UTF-8?q?variables=20=EB=B3=80=EC=97=AD=20(#3)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * variables 변역 * variables.md 변역 --- src/manual/variables.md | 116 +++++++++++++++++++--------------------- 1 file changed, 56 insertions(+), 60 deletions(-) diff --git a/src/manual/variables.md b/src/manual/variables.md index 317b162..08259e2 100644 --- a/src/manual/variables.md +++ b/src/manual/variables.md @@ -1,29 +1,30 @@ -# Variables +의 변수는 값에 연결된 (또는 바인딩 된) 이름입니다. 나중에 사용할 수 있도록 값 (예 : 일부 계산 후에 얻은 값)을 저장하려는 경우 유용합니다. -A variable, in Julia, is a name associated (or bound) to a value. It's useful when you want to -store a value (that you obtained after some math, for example) for later use. For example: +예 : ```julia-repl +# 변수 x에 10을 할당할때 # Assign the value 10 to the variable x julia> x = 10 10 -# Doing math with x's value +# x의 값으로 계산할떄 julia> x + 1 11 -# Reassign x's value +# x의값을 재설계할때 julia> x = 1 + 1 2 -# You can assign values of other types, like strings of text +# 텍스트 문자열과 같은 다른 유형의 값을 지정할 수 있습니다. + julia> x = "Hello World!" "Hello World!" ``` -Julia provides an extremely flexible system for naming variables. Variable names are case-sensitive, -and have no semantic meaning (that is, the language will not treat variables differently based -on their names). + Julia는 변수 명명에 매우 유연한 시스템을 제공합니다. 변수 이름은 대소 문자를 구 +분합니다. 그리고 의미 론적 의미가 없습니다 (즉, 언어는 변수를 다르게 취급하지 않 +습니다. ```jldoctest julia> x = 1.0 @@ -38,7 +39,7 @@ julia> Z = "My string" julia> customary_phrase = "Hello world!" "Hello world!" -julia> UniversalDeclarationOfHumanRightsStart = "人人生而自由，在尊严和权利上一律平等。" +julia> UniversalDeclarationOfHumanRightsStart = "人人生而自由，在尊严和权利上一>律平等。" "人人生而自由，在尊严和权利上一律平等。" ``` @@ -52,17 +53,10 @@ julia> 안녕하세요 = "Hello" "Hello" ``` -In the Julia REPL and several other Julia editing environments, you can type many Unicode math -symbols by typing the backslashed LaTeX symbol name followed by tab. For example, the variable -name `δ` can be entered by typing `\delta`-*tab*, or even `α̂₂` by `\alpha`-*tab*-`\hat`- -*tab*-`\_2`-*tab*. (If you find a symbol somewhere, e.g. in someone else's code, -that you don't know how to type, the REPL help will tell you: just type `?` and -then paste the symbol.) - -Julia will even let you redefine built-in constants and functions if needed (although -this is not recommended to avoid potential confusions): + a REPL 및 다른 여러 줄리아 편집 환경에서 많은 유니 코드 수학을 입력 할 수 있습>니다 백 슬래쉬 된 LaTeX 심볼 이름 다음에 탭을 입력하여 심볼을 제거하십시오.예를 를어 `TeX 심볼 이름 다음에 탭을 입력하여 심볼을 제거하십시오. 예를 들어, 변수 `delta`- * tab *을 입력하거나`\ alpha`- * tab * -` \ hat`- +* tab * -`\ _2` - * tab *. 다른 사람의 코드와 같이 기호를 어딘가에서 찾으면 +당신이 입력하는 방법을 모르겠다면, REPL 도움말은 당신에게 말할 것입니다 -```jldoctest julia> pi = 3 3 @@ -73,8 +67,8 @@ julia> sqrt = 4 4 ``` -However, if you try to redefine a built-in constant or function already in use, Julia will give -you an error: +그러나 이미 사용중인 내장 상수 또는 기능을 다시 정의하려고하면 +julia는 다음과같은 에러를 낼것이다 ```jldoctest julia> pi @@ -90,24 +84,28 @@ julia> sqrt = 4 ERROR: cannot assign variable Base.sqrt from module Main ``` -## Allowed Variable Names +##허용된 변수 이름 + -Variable names must begin with a letter (A-Z or a-z), underscore, or a subset of Unicode code -points greater than 00A0; in particular, [Unicode character categories](http://www.fileformat.info/info/unicode/category/index.htm) -Lu/Ll/Lt/Lm/Lo/Nl (letters), Sc/So (currency and other symbols), and a few other letter-like characters -(e.g. a subset of the Sm math symbols) are allowed. Subsequent characters may also include ! and -digits (0-9 and other characters in categories Nd/No), as well as other Unicode code points: diacritics -and other modifying marks (categories Mn/Mc/Me/Sk), some punctuation connectors (category Pc), -primes, and a few other characters. +변수 이름은 문자 (A-Z 또는 a-z), 밑줄 또는 유니 코드 코드의 하위 집합으로 시작해 +야합니다 +00A0보다 큰 점; 특히 [유니 코드 문자 범주] (http://www.fileformat.info/info/unicode/category/index.htm) +Lu / Ll / Lt / Lm / Lo / Nl (문자), Sc / So (통화 및 기타 기호) 및 기타 문자와 >유사한 문자 +(예 : Sm 수학 기호의 서브 세트)이 허용됩니다. 그 다음 문자는 +숫자 (0-9 및 Nd / No 범주의 다른 문자) 및 기타 유니 코드 코드 포인트 : 발음 구별 + 기호 +및 기타 수정 표시 (Mn / Mc / Me / Sk 범주), 일부 구두점 커넥터 (범주 Pc), +소수 (primes) 및 몇 가지 다른 문자가 포함되어 있습니다. -Operators like `+` are also valid identifiers, but are parsed specially. In some contexts, operators -can be used just like variables; for example `(+)` refers to the addition function, and `(+) = f` -will reassign it. Most of the Unicode infix operators (in category Sm), such as `⊕`, are parsed -as infix operators and are available for user-defined methods (e.g. you can use `const ⊗ = kron` -to define `⊗` as an infix Kronecker product). Operators can also be suffixed with modifying marks, -primes, and sub/superscripts, e.g. `+̂ₐ″` is parsed as an infix operator with the same precedence as `+`. +`+`와 같은 연산자도 유효한 식별자이지만 특별히 구문 분석됩니다. 일부 상황에서는 연산자 +변수와 마찬가지로 사용할 수 있습니다. 예를 들어`(+)`는 더하기 함수를,`(+) = f`는그것을 재 할당합니다. `⊕ '와 같은 대부분의 유니 코드 중온 연산자 (범주 Sm에서)는 + 파싱됩니다 +중온 연산자 (infix operators)로 사용되며 사용자 정의 메소드 (예 :`const ⊗ = kron`를 사용할 수 있습니다. +'⊗`을 크로 니커 제품으로 정의). 연산자에는 수정 표시가 붙을 수 있습니다. +소수 (primes), 서브 / 윗 첨자 (sub / superscript). `+ ₐ '`는`+`와 같은 우선 순위 +를 가진 중위 연산자로 파싱됩니다. +명시 적으로 허용되지 않는 변수 이름은 내장 명령문의 이름입니다. -The only explicitly disallowed names for variables are the names of built-in statements: ```julia-repl julia> else = false @@ -117,26 +115,24 @@ julia> try = "No" ERROR: syntax: unexpected "=" ``` -Some Unicode characters are considered to be equivalent in identifiers. -Different ways of entering Unicode combining characters (e.g., accents) -are treated as equivalent (specifically, Julia identifiers are NFC-normalized). -The Unicode characters `ɛ` (U+025B: Latin small letter open e) -and `µ` (U+00B5: micro sign) are treated as equivalent to the corresponding -Greek letters, because the former are easily accessible via some input methods. - -## Stylistic Conventions - -While Julia imposes few restrictions on valid names, it has become useful to adopt the following -conventions: - - * Names of variables are in lower case. - * Word separation can be indicated by underscores (`'_'`), but use of underscores is discouraged - unless the name would be hard to read otherwise. - * Names of `Type`s and `Module`s begin with a capital letter and word separation is shown with upper - camel case instead of underscores. - * Names of `function`s and `macro`s are in lower case, without underscores. - * Functions that write to their arguments have names that end in `!`. These are sometimes called - "mutating" or "in-place" functions because they are intended to produce changes in their arguments - after the function is called, not just return a value. - -For more information about stylistic conventions, see the [Style Guide](@ref). + +일부 유니 코드 문자는 식별자에서 동등한 것으로 간주됩니다. +문자 조합 (예 : 악센트)을 입력하는 다양한 방법 +(줄리아 식별자는 NFC 표준화되어 있음). +유니 코드 문자`ɛ` (U + 025B : 라틴 소문자 e) +및 'μ'(U + 00B5 : 마이크로 부호)는 대응하는 +전자는 일부 입력 방법을 통해 쉽게 액세스 할 수 있기 때문에 그리스 문자를 사용합>니다. +## 문체 규칙 + + +Julia는 유효한 이름에 대해 제한을 두지 않지만 다음을 채택하는 것이 유용 해졌습니 +다 +협약 : + + * 변수는 소문자를 사용합니다. + * (`'_'`)를 사용할수 있지만,사용 안하는 것이 좋습니다.(다른사람이 사용하기 불 + 편합니다) + * `Type`과`Module`의 이름은 대문자로 시작하고 단어 분리는 upper + camel 경우에 대신에 underscores. + * `함수`와`매크로`의 이름에는 밑줄을 넣지 않습니다 + * 인수에 쓰는 함수의 이름은!로 끝납니다. 이들은 때때로 "mutating"또는 "in-place"함수라고 불리는데, 그 이유는 값을 반환하는 것이 아니라 함수가 호출 된 후에 인>수가 변경되기 때문입니다. From eaf850f1ccbf791041c2ca2065fcf60f3954ff04 Mon Sep 17 00:00:00 2001 From: songnari Date: Fri, 1 Dec 2017 00:58:47 +0900 Subject: [PATCH 2/4] ~Background and Referemes --- .../integers-and-floating-point-numbers.md | 208 ++++++------------ 1 file changed, 71 insertions(+), 137 deletions(-) diff --git a/src/manual/integers-and-floating-point-numbers.md b/src/manual/integers-and-floating-point-numbers.md index 4338775..f80569d 100644 --- a/src/manual/integers-and-floating-point-numbers.md +++ b/src/manual/integers-and-floating-point-numbers.md @@ -1,24 +1,17 @@ -# Integers and Floating-Point Numbers +# 정수와 부동소수점으로 표현되는 실수 -Integers and floating-point values are the basic building blocks of arithmetic and computation. -Built-in representations of such values are called numeric primitives, while representations of -integers and floating-point numbers as immediate values in code are known as numeric literals. -For example, `1` is an integer literal, while `1.0` is a floating-point literal; their binary -in-memory representations as objects are numeric primitives. +정수와 부동소수점(floating-point)으로 표현되는 실수는 수치 연산에 있어서 가장 기본적인 구성 요소이다. +이와 같은 값들의 Julia 내부에서의 내장 표현은 숫자 프라미티브(numberic primitives)이라고 하고, 실수나 부동소수점처럼 코드상에서 즉각적으로 표현되는 값을은 수치형 리터럴(numeric literal)이라고 알려져있다. +예를들어, `1`은 정수형 리터럴이지만, `1.0`은 부동소수점 리터럴이다; 그리고 위 리터럴들이 바이너리 형태로 메모리상에서 표현되는 객체(object)를 숫자 프리미티브(numeric primitives)라고 한다. -Julia provides a broad range of primitive numeric types, and a full complement of arithmetic and -bitwise operators as well as standard mathematical functions are defined over them. These map -directly onto numeric types and operations that are natively supported on modern computers, thus -allowing Julia to take full advantage of computational resources. Additionally, Julia provides -software support for [Arbitrary Precision Arithmetic](@ref), which can handle operations on numeric -values that cannot be represented effectively in native hardware representations, but at the cost -of relatively slower performance. +Julia는 넓은 범위의 기본 수치 타입과 수치연산자, 그리고 비트연산자를 모두 제공한다. +현대의 컴퓨터에서 기본으로 제공되는 Julia에 내장된 표준 수학 함수들은 Julia로 하여금 연산 자원을 최대한 활용 수 있도록 한다. 게다가 Julia는 하드웨어에서 기본적으로 표현하지 못하는 자들을 표현할 수 있게 만든 [] Additionally, Julia provides [Arbitrary Precision Arithmetic](@ref)를 지원한다. 그러나 [Arbitrary precision Arithmetic](@ref) 사용하면 성능상으로 느려질 수 있다 -The following are Julia's primitive numeric types: +다음은 Julia에서 기본적으로 지원하는 타입니다: - * **Integer types:** + * **정수형 타입:** -| Type | Signed? | Number of bits | Smallest value | Largest value | +| 타입 | 부호 여부 | 비트 수 | 최솟값 | 최댓값 | |:----------------- |:------- |:-------------- |:-------------- |:------------- | | [`Int8`](@ref) | ✓ | 8 | -2^7 | 2^7 - 1 | | [`UInt8`](@ref) |   | 8 | 0 | 2^8 - 1 | @@ -32,21 +25,19 @@ The following are Julia's primitive numeric types: | [`UInt128`](@ref) |   | 128 | 0 | 2^128 - 1 | | [`Bool`](@ref) | N/A | 8 | `false` (0) | `true` (1) | - * **Floating-point types:** + * **부동소수점 타입:** -| Type | Precision | Number of bits | +| 타입 | 정밀도 | 비트 수 | |:----------------- |:------------------------------------------------------------------------------ |:-------------- | | [`Float16`](@ref) | [half](https://en.wikipedia.org/wiki/Half-precision_floating-point_format) | 16 | | [`Float32`](@ref) | [single](https://en.wikipedia.org/wiki/Single_precision_floating-point_format) | 32 | | [`Float64`](@ref) | [double](https://en.wikipedia.org/wiki/Double_precision_floating-point_format) | 64 | -Additionally, full support for [Complex and Rational Numbers](@ref) is built on top of these primitive -numeric types. All numeric types interoperate naturally without explicit casting, thanks to a -flexible, user-extensible [type promotion system](@ref conversion-and-promotion). +추가적으로 [Complex and Rational Numbers](@ref)는 위ㅔ어서 언급한 타입에 기초하여 만들어졌다. 모든 기본 수치 타입들은 유연하고, 쉽게 확장이 가능한 [type promotion system](@ref conversion-and-promotion) 덕분에 자유롭게 상호운용이 가능하다. -## Integers +## 정수 -Literal integers are represented in the standard manner: +정수 리터럴은 다음과 같은 표준적인 방식으로 표한한다: ```jldoctest julia> 1 @@ -56,8 +47,7 @@ julia> 1234 1234 ``` -The default type for an integer literal depends on whether the target system has a 32-bit architecture -or a 64-bit architecture: +정수 리터럴은 해당 시스템이 32비트 아키텍처인지 혹은 64비트 아키텍처인지에 따라 결정된다: ```julia-repl # 32-bit system: @@ -69,8 +59,7 @@ julia> typeof(1) Int64 ``` -The Julia internal variable [`Sys.WORD_SIZE`](@ref) indicates whether the target system is 32-bit -or 64-bit: +Julia의 내부변수 [`Sys.WORD_SIZE`](@ref)는 해당 시스템이 32비트인지 64비트인지 알려주는 역할을 한다: ```julia-repl # 32-bit system: @@ -82,8 +71,7 @@ julia> Sys.WORD_SIZE 64 ``` -Julia also defines the types `Int` and `UInt`, which are aliases for the system's signed and unsigned -native integer types respectively: +Julia는 부호가 있는 정수형과 부호가 없는 정수형을 위해 `Int`와 `UInt`라는 타입 또한 정의하고 있다: ```julia-repl # 32-bit system: @@ -99,8 +87,7 @@ julia> UInt UInt64 ``` -Larger integer literals that cannot be represented using only 32 bits but can be represented in -64 bits always create 64-bit integers, regardless of the system type: +32비트로 표현할 수 없지만 64비트로 표현이 가능한 큰 정수형 리터럴은 시스템의 타입과는 상관없이 항상 64비트를 생성한다: ```jldoctest # 32-bit or 64-bit system: @@ -108,9 +95,7 @@ julia> typeof(3000000000) Int64 ``` -Unsigned integers are input and output using the `0x` prefix and hexadecimal (base 16) digits -`0-9a-f` (the capitalized digits `A-F` also work for input). The size of the unsigned value is -determined by the number of hex digits used: +부호가 없는 정수형의 입출력은 항상 `0x`라는 접두어가 붙으며 16진수는 `0-9a-f`범위의 숫자와 문자를 쓴다.(입력할 때, 대문자 `A-F`도 쓸 수 있다.) : ```jldoctest julia> 0x1 @@ -138,14 +123,11 @@ julia> typeof(ans) UInt64 ``` -This behavior is based on the observation that when one uses unsigned hex literals for integer -values, one typically is using them to represent a fixed numeric byte sequence, rather than just -an integer value. +일반적으로 부호가 없는 16진수 정수 리터럴을 쓸 때, 단순히 정수를 표현사기 보다는 사람들은 고정된 바이트 시퀀스(fixed numeric byte sequence)를 표현하기 위해 16진수를 쓰는 경향이 있기 때문에, 위와 같이 부호가 없는 정수형에 16진수 형태를 결합시키도록 하였다. -Recall that the variable [`ans`](@ref) is set to the value of the last expression evaluated in -an interactive session. This does not occur when Julia code is run in other ways. +[`ans`](@ref) 가 대화형 실행 환경에서 가장 최근에 실행된 표현식의 결과를 나타내었다는 것을 떠올려보면, 위의 Julia 코드는 다른 환경에서는 제대로 실행이 안될 것이라는 것을 알 수 있다. -Binary and octal literals are also supported: +Julia는 2진수와 8진수 리터럴 또한 지원한다: ```jldoctest julia> 0b10 @@ -161,8 +143,7 @@ julia> typeof(ans) UInt8 ``` -The minimum and maximum representable values of primitive numeric types such as integers are given -by the [`typemin`](@ref) and [`typemax`](@ref) functions: +정수형과 같은 기본 수치 타입의 최소값과 최대값은 [`typemin`](@ref)과 [`typemax`](@ref) 함수를 통해 알 수 있다: ```jldoctest julia> (typemin(Int32), typemax(Int32)) @@ -183,14 +164,12 @@ julia> for T in [Int8,Int16,Int32,Int64,Int128,UInt8,UInt16,UInt32,UInt64,UInt12 UInt128: [0,340282366920938463463374607431768211455] ``` -The values returned by [`typemin`](@ref) and [`typemax`](@ref) are always of the given argument -type. (The above expression uses several features we have yet to introduce, including [for loops](@ref man-loops), -[Strings](@ref man-strings), and [Interpolation](@ref), but should be easy enough to understand for users -with some existing programming experience.) +[`typemin`](@ref)과 [`typemax`](@ref)가 제공하는 값들은 항상 매개변수의 타입과 같은 타입을 가진다. (위 예제에서 쓰는 [for loops](@ref man-loops), +[Strings](@ref man-strings), [Interpolation](@ref)과 같은 표현들은 아직 소개하지 않은 것들이다. 그러나 약간의 프로그래밍 지식이 있다면 이해하기 별 문제가 없을 것이다. ) -### Overflow behavior +### 오버플로우(Overflow) 동작 -In Julia, exceeding the maximum representable value of a given type results in a wraparound behavior: +Julia에서는 주어진 타입에서 표현할 수 있는 값을 넘어서게 되면 다음과 같이 주어진 범위를 벗어나지 않는(wraparound) 동작을 보여준다: ```jldoctest julia> x = typemax(Int64) @@ -203,23 +182,15 @@ julia> x + 1 == typemin(Int64) true ``` -Thus, arithmetic with Julia integers is actually a form of [modular arithmetic](https://en.wikipedia.org/wiki/Modular_arithmetic). -This reflects the characteristics of the underlying arithmetic of integers as implemented on modern -computers. In applications where overflow is possible, explicit checking for wraparound produced -by overflow is essential; otherwise, the [`BigInt`](@ref) type in [Arbitrary Precision Arithmetic](@ref) -is recommended instead. +위와 같기 때문에, Juali 정수의 연산은 사실 [나머지 연산](https://en.wikipedia.org/wiki/Modular_arithmetic)임을 알 수 있다. 오버플로우가 나올 수 있는 프로그램에서는 오버플로우를 명시적으로 체크하는 것이 필수적이다; 그런 경우가 아니라면 [Arbitrary Precision Arithmetic](@ref)에서 [`BigInt`](@ref)타입을 사용하는 것을 추천한다. -### Division errors +### 나눗셈 관련 에러들 -Integer division (the `div` function) has two exceptional cases: dividing by zero, and dividing -the lowest negative number ([`typemin`](@ref)) by -1. Both of these cases throw a [`DivideError`](@ref). -The remainder and modulus functions (`rem` and `mod`) throw a [`DivideError`](@ref) when their -second argument is zero. +정수의 나눗셈 연산 (`div` 함수)는 두 가지 예외적인 경우가 있다; 0으로 나누기, 그리고 컴퓨터가 표현할 수 있는 최소의 음의 정수값([`typemin`](@ref))을 -1로 나누는 것이다. 두 가지 경우 [`DivideError`](@ref)를 유발한다. 두 나머지 연산 함수( `rem`과 `mod`)는 두 번째 매개변수가 0일 때, [`DivideError`](@ref)를 던진다(throw). -## Floating-Point Numbers +## 부동소수점으로 표현되는 실수 -Literal floating-point numbers are represented in the standard formats, using -[E-notation](https://en.wikipedia.org/wiki/Scientific_notation#E-notation) when necessary: +부동소수점 리터럴은 필요할 때 [E-notation](https://en.wikipedia.org/wiki/Scientific_notation#E-notation) 표준 포맷을 이용하여 표현된다: ```jldoctest julia> 1.0 @@ -244,8 +215,7 @@ julia> 2.5e-4 0.00025 ``` -The above results are all [`Float64`](@ref) values. Literal [`Float32`](@ref) values can be -entered by writing an `f` in place of `e`: +위에 나온 결과는 모두 [`Float64`](@ref)타입의 값들이다. [`Float32`](@ref)값들은 `e`대신 `f`를 쓰면 입력할 수 있다: ```jldoctest julia> 0.5f0 @@ -258,7 +228,7 @@ julia> 2.5f-4 0.00025f0 ``` -Values can be converted to [`Float32`](@ref) easily: +값들은 쉽게 [`Float32`](@ref)타입으로 변환할 수 있다: ```jldoctest julia> Float32(-1.5) @@ -268,8 +238,7 @@ julia> typeof(ans) Float32 ``` -Hexadecimal floating-point literals are also valid, but only as [`Float64`](@ref) values, -with `p` preceding the base-2 exponent: +16진수로 표현되는 부동소수점 리터럴은 유효하지만, Base-2 이전에 `p`를 사는 경우 [`Float64`](@ref)타입에서만 가능하다: ```jldoctest julia> 0x1p0 @@ -285,8 +254,7 @@ julia> typeof(ans) Float64 ``` -Half-precision floating-point numbers are also supported ([`Float16`](@ref)), but they are -implemented in software and use [`Float32`](@ref) for calculations. +16비트의 정밀도가 절반인 부동소수점(Half-precision floating-point)([`Float16`](@ref))도 지원되지만, 계산을 위해 [`Float32`](@ref)를 사용한 소프트웨어로 구현되어있다. ```jldoctest julia> sizeof(Float16(4.)) @@ -296,18 +264,16 @@ julia> 2*Float16(4.) Float16(8.0) ``` -The underscore `_` can be used as digit separator: +밑줄`_`는 수 구분자로 쓰일 수 있다: ```jldoctest julia> 10_000, 0.000_000_005, 0xdead_beef, 0b1011_0010 (10000, 5.0e-9, 0xdeadbeef, 0xb2) ``` -### Floating-point zero +### 실수로서의 숫자 0 -Floating-point numbers have [two zeros](https://en.wikipedia.org/wiki/Signed_zero), positive zero -and negative zero. They are equal to each other but have different binary representations, as -can be seen using the `bits` function: : +부동 소수점은 양수 0과 음수 0으로 불리는 [두 개의 0](https://en.wikipedia.org/wiki/Signed_zero)을 가진다. 그 둘은 값은 0으로써 같지만, 다음과 같이 `bits`함수를 잉ㅇ하면 알 수 있듯이, 바이너리로 표기했을 때 다르다는 것을 알 수 있다: ```jldoctest julia> 0.0 == -0.0 @@ -320,20 +286,17 @@ julia> bitstring(-0.0) "1000000000000000000000000000000000000000000000000000000000000000" ``` -### Special floating-point values +### 특별한 부동 소수점 값들 -There are three specified standard floating-point values that do not correspond to any point on -the real number line: +다음은 실수에는 포함되지는 않은 세 종류의 특정 표준 부동 소수점이 있다: -| `Float16` | `Float32` | `Float64` | Name | Description | +| `Float16` | `Float32` | `Float64` | 이름 | 설명 | |:--------- |:--------- |:--------- |:----------------- |:--------------------------------------------------------------- | -| `Inf16` | `Inf32` | `Inf` | positive infinity | a value greater than all finite floating-point values | -| `-Inf16` | `-Inf32` | `-Inf` | negative infinity | a value less than all finite floating-point values | -| `NaN16` | `NaN32` | `NaN` | not a number | a value not `==` to any floating-point value (including itself) | +| `Inf16` | `Inf32` | `Inf` | positive infinity | 모든 유한한 부동 소수점 실수보다 큰 값 | +| `-Inf16` | `-Inf32` | `-Inf` | negative infinity | 모든 유한한 부동 소수점 실수보다 작은 값 | +| `NaN16` | `NaN32` | `NaN` | not a number | 어떤 부동 소수점 실수와도 같지 않은 값 | -For further discussion of how these non-finite floating-point values are ordered with respect -to each other and other floats, see [Numeric Comparisons](@ref). By the [IEEE 754 standard](https://en.wikipedia.org/wiki/IEEE_754-2008), -these floating-point values are the results of certain arithmetic operations: +이와 같은 유한하지 않은 부동 소수점 값들이 서로와 다른 실수에 대해서 순서를 매길 때에는 [Numeric Comparisons](@ref)를 참고하길 바란다. [IEEE 754 standard](https://en.wikipedia.org/wiki/IEEE_754-2008)에 따르면, 위에서의 부동 소수점 실수들은 어떤 산술 연산에 의한 결과임을 알 수 있다: ```jldoctest julia> 1/Inf @@ -373,7 +336,7 @@ julia> 0 * Inf NaN ``` -The [`typemin`](@ref) and [`typemax`](@ref) functions also apply to floating-point types: +[`typemin`](@ref)과 [`typemax`](@ref) 함수는 부동 소수점 타입에도 적용이 가능하다: ```jldoctest julia> (typemin(Float16),typemax(Float16)) @@ -386,14 +349,11 @@ julia> (typemin(Float64),typemax(Float64)) (-Inf, Inf) ``` -### Machine epsilon +### 계산기 입실론(Machine epsilon) -Most real numbers cannot be represented exactly with floating-point numbers, and so for many purposes -it is important to know the distance between two adjacent representable floating-point numbers, -which is often known as [machine epsilon](https://en.wikipedia.org/wiki/Machine_epsilon). +대부분 실수들은 부동 소수점 형태로는 정확하게 표현할 수 없다. 그리고 현재로서는 많은 경우 두 인접한 부동 소수점으로 표현 가능한 실수가 얼만큼 떨어져 있는지 알 필요가 있다. 따라서 이를 위해 계산기 입실론([machine epsilon](https://en.wikipedia.org/wiki/Machine_epsilon))이라는 개념이 도입하게 되었다. -Julia provides [`eps`](@ref), which gives the distance between `1.0` and the next larger representable -floating-point value: +Julia는 [`eps`](@ref)라는 것을 제공한다. 이는 `1.0`과 `1.0` 다음으로 큰 표현 가능한 부동 소수점 값과의 거리를 말한다: ```jldoctest julia> eps(Float32) @@ -406,11 +366,7 @@ julia> eps() # same as eps(Float64) 2.220446049250313e-16 ``` -These values are `2.0^-23` and `2.0^-52` as [`Float32`](@ref) and [`Float64`](@ref) values, -respectively. The [`eps`](@ref) function can also take a floating-point value as an -argument, and gives the absolute difference between that value and the next representable -floating point value. That is, `eps(x)` yields a value of the same type as `x` such that -`x + eps(x)` is the next representable floating-point value larger than `x`: +위 코드에서 나오는 값들은 [`Float64`](@ref)와 [`Float64`](@ref)값 중에서 바이너리로 표기했을 때, `2.0^-23`과 `2.0^-52`를 각각 나타낸다. [`eps`](@ref) 함수는 부동 소수점 실수를 매개변수로 받을 수도 있는데, 이 때는 `1.0`이 아니라 주어진 값과 주어진 값 바로 옆에서 주어진 값과의 거리를 반환한다. 그 말은 `epx(x)`의 반환값은 `x`와 같은 타입이고, `x+eps(x)`는 `x`보다 큰 `x`바로 옆에 있는 포현 가능한 부동 소수점 실수를 뜻한다: ```jldoctest julia> eps(1.0) @@ -426,14 +382,9 @@ julia> eps(0.0) 5.0e-324 ``` -The distance between two adjacent representable floating-point numbers is not constant, but is -smaller for smaller values and larger for larger values. In other words, the representable floating-point -numbers are densest in the real number line near zero, and grow sparser exponentially as one moves -farther away from zero. By definition, `eps(1.0)` is the same as `eps(Float64)` since `1.0` is -a 64-bit floating-point value. +두 인접하면서 표현 가능한 부동 소수점 실수들은 상수가 아니지만, 작은 값에서는 작은 값을 지니고, 큰 값들에서는 큰 값을 나타낸다. 다른 말로 하면, 표현 가능한 부동 소수점 실수들은 실수축 상에서 0에 근접할 때 가장 밀집되어있고, 0에서 멀어질수록 점점 드물다. 정의에 의하면, `eps(1,0)`은 `eps(Float64)`와 같은데, 그 이유는 `1.0`은 64비트 부동 소수점 실수이기 때문이다. -Julia also provides the [`nextfloat`](@ref) and [`prevfloat`](@ref) functions which return -the next largest or smallest representable floating-point number to the argument respectively: +또한 Julia는 [`nextfloat`](@ref)과 [`prevfloat`](@ref) 함수를 제공하는데, 이는 표현 가능한 부동 소수점 실수 중에서 주어진 실수 바로 옆에있는 크거나 작은 수를 반환한다: ```jldoctest julia> x = 1.25f0 @@ -455,14 +406,11 @@ julia> bitstring(nextfloat(x)) "00111111101000000000000000000001" ``` -This example highlights the general principle that the adjacent representable floating-point numbers -also have adjacent binary integer representations. +위의 예제는 서로 이웃한 표현 가능한 부동 소수점 수는 바이너리 정수 표기법을 가질 수 있다는 기본적인 원리를 새삼 일깨워준다. -### Rounding modes +### 반올림 모드 -If a number doesn't have an exact floating-point representation, it must be rounded to an appropriate -representable value, however, if wanted, the manner in which this rounding is done can be changed -according to the rounding modes presented in the [IEEE 754 standard](https://en.wikipedia.org/wiki/IEEE_754-2008). +만약 어떤 숫자가 정확한 부동 소수점 표현을 가지고 있지 않다면, 그 수는 반드시 어떤 표현 가능한 값으로 반올림되어야 한다. 그러나, 만약 사용자가 원한다면[IEEE 754 standard](https://en.wikipedia.org/wiki/IEEE_754-2008)에 따라 반올림 방식을 변경할 수 있다. ```jldoctest julia> x = 1.1; y = 0.1; @@ -476,35 +424,21 @@ julia> setrounding(Float64,RoundDown) do 1.2 ``` -The default mode used is always [`RoundNearest`](@ref), which rounds to the nearest representable -value, with ties rounded towards the nearest value with an even least significant bit. - -!!! warning - Rounding is generally only correct for basic arithmetic functions ([`+`](@ref), [`-`](@ref), - [`*`](@ref), [`/`](@ref) and [`sqrt`](@ref)) and type conversion operations. Many other - functions assume the default [`RoundNearest`](@ref) mode is set, and can give erroneous results - when operating under other rounding modes. - -### Background and References - -Floating-point arithmetic entails many subtleties which can be surprising to users who are unfamiliar -with the low-level implementation details. However, these subtleties are described in detail in -most books on scientific computation, and also in the following references: - - * The definitive guide to floating point arithmetic is the [IEEE 754-2008 Standard](http://standards.ieee.org/findstds/standard/754-2008.html); - however, it is not available for free online. - * For a brief but lucid presentation of how floating-point numbers are represented, see John D. - Cook's [article](https://www.johndcook.com/blog/2009/04/06/anatomy-of-a-floating-point-number/) - on the subject as well as his [introduction](https://www.johndcook.com/blog/2009/04/06/numbers-are-a-leaky-abstraction/) - to some of the issues arising from how this representation differs in behavior from the idealized - abstraction of real numbers. - * Also recommended is Bruce Dawson's [series of blog posts on floating-point numbers](https://randomascii.wordpress.com/2012/05/20/thats-not-normalthe-performance-of-odd-floats/). - * For an excellent, in-depth discussion of floating-point numbers and issues of numerical accuracy - encountered when computing with them, see David Goldberg's paper [What Every Computer Scientist Should Know About Floating-Point Arithmetic](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.22.6768&rep=rep1&type=pdf). - * For even more extensive documentation of the history of, rationale for, and issues with floating-point - numbers, as well as discussion of many other topics in numerical computing, see the [collected writings](https://people.eecs.berkeley.edu/~wkahan/) - of [William Kahan](https://en.wikipedia.org/wiki/William_Kahan), commonly known as the "Father - of Floating-Point". Of particular interest may be [An Interview with the Old Man of Floating-Point](https://people.eecs.berkeley.edu/~wkahan/ieee754status/754story.html). +기본 반올림 모드는 항상 [`RoundNearest`](@ref)이다. 이는 가장 근접한 표현 가능한 값으로 반올림 하지만, 만약 두 표현 값 중간에 주어진 값이 걸쳐 있으면 가수부 값 중 짝수(바이너리 임으로 0)로 반올림 하는 모드이다. + +!!! 경고 + : 반올림은 일반적으로 기본 산술 함수([`+`](@ref), [`-`](@ref), + [`*`](@ref), [`/`](@ref), [`sqrt`](@ref))와 타입 변환 연산에서만 정확하다. 많은 다른 함수들은 기본 값인 [`RoundNearest`](@ref)를 가정하고 짜여져 있고, 이는 다른 반올림 모드에서는 부정확한 값을 제공할 수 있다. + +### 부동 소수점 실수에 대해서 더 읽으면 좋은 문서들 + +부동 소수점 연산은 많은 미묘한 것들을 수반하고 있기 때문에 저수준(low-level) 구현에 익숙하지 않은 유저들은 당활할 수도 있다. 그러나 그 미묘한 점들은 과학적 연산과 관련된 많은 책들에서 잘 설명되고 있고, 아래에 나열하는 참고문헌도 참고하면 좋을 것이다: + + * 부동 소수점과 관련해서 가장 확실한 가이드는 [IEEE 754-2008 Standard](http://standards.ieee.org/findstds/standard/754-2008.html)이지만, 유료이다. + * 부동 소수점이 어떻게 표현되는지에 대한 간략하면서도 명쾌한 설명은 John D. Cook's [블로그 글](https://www.johndcook.com/blog/2009/04/06/anatomy-of-a-floating-point-number/)를 참고하면 된다. 같은 주제에 관하여 이와 더불어서 그의 [소개글](https://www.johndcook.com/blog/2009/04/06/numbers-are-a-leaky-abstraction/)은 부동 소수점이 실수의 이상적인 추상화와 다름으로써 생기는 몇가지 문제에 대해서도 다루고 있다. + * Bruce Dawson의 [series of blog posts on floating-point numbers](https://randomascii.wordpress.com/2012/05/20/thats-not-normalthe-performance-of-odd-floats/)도 추천하는 바이다. + * 상급자들은 부동 소수점의 내부 구현에 관한 이야기들과 부동 소수점 연산을 할 때 맞닥뜨릴 수 있는 수치적인 정확도에 관한 문제들에 대해서는 David Goldberg의 논문 [What Every Computer Scientist Should Know About Floating-Point Arithmetic](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.22.6768&rep=rep1&type=pdf)를 참고하는 것이 좋다. + * 특별히 부동 소수점의 역사, 근거 및 문제점에 대한 훨씬 더 자세한 문서화, 수치 컴퓨팅에서의 토론은 일반적으로 "부동 소수점의 아버지"로 알려진 [William Kahan](https://en.wikipedia.org/wiki/William_Kahan)의 [collected writings](https://people.eecs.berkeley.edu/~wkahan/)을 참조하세요. 관심이 더 생긴다면 [An Interview with the Old Man of Floating-Point](https://people.eecs.berkeley.edu/~wkahan/ieee754status/754story.html)를 읽기 바란다. ## Arbitrary Precision Arithmetic From 4e416ace1462fa33273b0f6293c9e5b9e665ccbb Mon Sep 17 00:00:00 2001 From: songnari Date: Fri, 1 Dec 2017 12:06:11 +0900 Subject: [PATCH 3/4] 4 category translation Arbitrary Precision Arithmetic, Numeric Litera, Syntax Confilicts, Literal zero and one --- .../integers-and-floating-point-numbers.md | 80 +++++++------------ 1 file changed, 27 insertions(+), 53 deletions(-) diff --git a/src/manual/integers-and-floating-point-numbers.md b/src/manual/integers-and-floating-point-numbers.md index f80569d..d36c838 100644 --- a/src/manual/integers-and-floating-point-numbers.md +++ b/src/manual/integers-and-floating-point-numbers.md @@ -440,16 +440,11 @@ julia> setrounding(Float64,RoundDown) do * 상급자들은 부동 소수점의 내부 구현에 관한 이야기들과 부동 소수점 연산을 할 때 맞닥뜨릴 수 있는 수치적인 정확도에 관한 문제들에 대해서는 David Goldberg의 논문 [What Every Computer Scientist Should Know About Floating-Point Arithmetic](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.22.6768&rep=rep1&type=pdf)를 참고하는 것이 좋다. * 특별히 부동 소수점의 역사, 근거 및 문제점에 대한 훨씬 더 자세한 문서화, 수치 컴퓨팅에서의 토론은 일반적으로 "부동 소수점의 아버지"로 알려진 [William Kahan](https://en.wikipedia.org/wiki/William_Kahan)의 [collected writings](https://people.eecs.berkeley.edu/~wkahan/)을 참조하세요. 관심이 더 생긴다면 [An Interview with the Old Man of Floating-Point](https://people.eecs.berkeley.edu/~wkahan/ieee754status/754story.html)를 읽기 바란다. -## Arbitrary Precision Arithmetic +## 임의 정밀도 연산 -To allow computations with arbitrary-precision integers and floating point numbers, Julia wraps -the [GNU Multiple Precision Arithmetic Library (GMP)](https://gmplib.org) and the [GNU MPFR Library](http://www.mpfr.org), -respectively. The [`BigInt`](@ref) and [`BigFloat`](@ref) types are available in Julia for arbitrary -precision integer and floating point numbers respectively. +임의 정밀도의 정수와 부동 소수점들의 연산을 위해, Julia는 [GNU Multiple Precision Arithmetic Library (GMP)](https://gmplib.org)와 [GNU MPFR Library](http://www.mpfr.org)을 각각 래빙(wrapping)하였다. [`BigInt`](@ref)와 [`BigFloat`](@ref)타입은 Julia에서 각각 임의 정밀도의 정수와 부동 소수점을 다루기 위해 사용되고 있다. -Constructors exist to create these types from primitive numerical types, and [`parse`](@ref) -can be used to construct them from `AbstractString`s. Once created, they participate in arithmetic -with all other numeric types thanks to Julia's [type promotion and conversion mechanism](@ref conversion-and-promotion): +기본 수치 타입으로부터 임의 정밀도 정수와 부동 소수점 타입을 만들기 위해 생성자가 존재하며, [`parse`](@ref)는 `AbstractString`들로 부터 임의 정밀도 타입을 만들 수 있게 해준다. 한번 임의 정밀도 타입이 만들어지면, [type promotion and conversion mechanism](@ref conversion-and-promotion)덕분에 자유롭게 다른 수치타입과 연산을 수행할 수 있다: ```jldoctest julia> BigInt(typemax(Int64)) + 1 @@ -468,8 +463,7 @@ julia> factorial(BigInt(40)) 815915283247897734345611269596115894272000000000 ``` -However, type promotion between the primitive types above and [`BigInt`](@ref)/[`BigFloat`](@ref) -is not automatic and must be explicitly stated. +그러나, 기본 타입과 [`BigInt`](@ref)/[`BigFloat`](@ref)간의 묵시적 형 변환(type promotion)은 자동으로 이루어지지 않고, 반드시 명시적으로 처리되어야 한다. ```jldoctest julia> x = typemin(Int64) @@ -491,11 +485,7 @@ julia> typeof(y) BigInt ``` -The default precision (in number of bits of the significand) and rounding mode of [`BigFloat`](@ref) -operations can be changed globally by calling [`setprecision`](@ref) and [`setrounding`](@ref), -and all further calculations will take these changes in account. Alternatively, the precision -or the rounding can be changed only within the execution of a particular block of code by using -the same functions with a `do` block: +[`BigFloat`](@ref)타입에서 기본 정밀도(가수부의 비트수)와 반올림 모드는 [`setprecision`](@ref)와 [`setrounding`](@ref)를 호출함으로써 변경할 수 있으며, 한 번 호출된 이후에는 그 설정이 계속 유지 된다. 특정 블럭의 코드에서만 정밀도와 반올림을 변경하기 위해서는 `do`블럭의 코드에서와 같은 함수를 호출한다: ```jldoctest julia> setrounding(BigFloat, RoundUp) do @@ -514,11 +504,9 @@ julia> setprecision(40) do 1.1000000000004 ``` -## [Numeric Literal Coefficients](@id man-numeric-literal-coefficients) +## [수치형 리터럴 계수](@id man-numeric-literal-coefficients) -To make common numeric formulas and expressions clearer, Julia allows variables to be immediately -preceded by a numeric literal, implying multiplication. This makes writing polynomial expressions -much cleaner: +보통의 수학 식과 표현식을 깔끔하게 표현하기 위해서, Julia는 변수가 수치형 리터럴 바로 다음에 있으면 둘 사이의 관계가 곱셈임을 가정한다. 이는 다항식의 표현을 더욱 깔끔하게 만든다: ```jldoctest numeric-coefficients julia> x = 3 @@ -531,17 +519,16 @@ julia> 1.5x^2 - .5x + 1 13.0 ``` -It also makes writing exponential functions more elegant: +이는 지수함수의 표현도 매우 아름답게 만들 수 있다: ```jldoctest numeric-coefficients julia> 2^2x 64 ``` -The precedence of numeric literal coefficients is the same as that of unary operators such as -negation. So `2^3x` is parsed as `2^(3x)`, and `2x^3` is parsed as `2*(x^3)`. +수치형 리터럴 계수의 선행(precedence)도 부정연산과 같은 단항 연산과 같이 작동한다. 따라서 `2^3x`는 `2^(3x)`으로, `2x^3`은 `2*(x^3)`으로 파싱(parsing)된다. -Numeric literals also work as coefficients to parenthesized expressions: +수치형 리터럴은 괄호가 있는 식에서도 계수(coeffiients)로 작동할 수 있다: ```jldoctest numeric-coefficients julia> 2(x-1)^2 - 3(x-1) + 1 @@ -553,16 +540,14 @@ julia> 2(x-1)^2 - 3(x-1) + 1 (`*`), and division (`/`, `\`, and `//`). This means, for example, that `1 / 2im` equals `-0.5im` and `6 // 2(2 + 1)` equals `1 // 1`. -Additionally, parenthesized expressions can be used as coefficients to variables, implying multiplication -of the expression by the variable: +게다가 괄호 표현식은 변수 또한 계수로 생각하여, 곱셈기호 없이도 변수들 간의 곱으로 식을 표현할 수도 있다: ```jldoctest numeric-coefficients julia> (x-1)x 6 ``` -Neither juxtaposition of two parenthesized expressions, nor placing a variable before a parenthesized -expression, however, can be used to imply multiplication: +그러나 두 괄호식을 병치하거나 괄호식 앞에 변수를 두는 경우는 계수로 사용할 수 없다: ```jldoctest numeric-coefficients julia> (x-1)(x+1) @@ -572,43 +557,32 @@ julia> x(x+1) ERROR: MethodError: objects of type Int64 are not callable ``` -Both expressions are interpreted as function application: any expression that is not a numeric -literal, when immediately followed by a parenthetical, is interpreted as a function applied to -the values in parentheses (see [Functions](@ref) for more about functions). Thus, in both of these -cases, an error occurs since the left-hand value is not a function. +두 표현식은 함수로써 인식된다. 괄호앞에 붙는 수치형 리터럴이 아닌 표현식들은 모두 함수와 함수의 매개변수로 인식된다(자세한 설명을 위해서는 [Functions](@ref)를 참고하도록 하자). 그래서 두 가지 경우 모두 왼쪽에 있는 값이 함수가 아님을 알려주는 에러가 발생한다. -The above syntactic enhancements significantly reduce the visual noise incurred when writing common -mathematical formulae. Note that no whitespace may come between a numeric literal coefficient -and the identifier or parenthesized expression which it multiplies. +위에서 언급한 문법적 강화효과는 수학식을 작성할 때 생기는 시각적 공해를 줄일 수 있도록 해준다. 단지 한 가지 알아야 할 점은 수치형 계수와 이에 곱해지는 변수 혹은 괄호식 등 사이에는 빈칸이 있어서는 안된다. -### Syntax Conflicts +### 문법적 충돌 -Juxtaposed literal coefficient syntax may conflict with two numeric literal syntaxes: hexadecimal -integer literals and engineering notation for floating-point literals. Here are some situations -where syntactic conflicts arise: +리터럴 계수를 병치하는 문법은 16진수 정수 리터럴과 부동 소수점의 공학적 표현이라는 두 수치형 리터럴 문법과 충돌이 생길 수 있다. 다음은 문법적 충돌이 발생하는 예이다: - * The hexadecimal integer literal expression `0xff` could be interpreted as the numeric literal - `0` multiplied by the variable `xff`. - * The floating-point literal expression `1e10` could be interpreted as the numeric literal `1` multiplied - by the variable `e10`, and similarly with the equivalent `E` form. + * 16진수 리터럴 표현식 `0xff`는 수치형 리터럴 `0`과 변수 `xff`의 곱셈으로 해석될 수 있다. + * 부동 소수점 리터럴 표현식 `1e10`은 수치형 리터럴 `1`이 변수 `e10`에 곱해지는 걸로 해석될 수 있고 이는 `e`가 아닌 `E`를 쓸 때에도 마찬가지이다. -In both cases, we resolve the ambiguity in favor of interpretation as a numeric literals: +이 두 가지 경우에, 우리는 수치형 리터러를 해석하는데 있어서 다음과 같은 방식으로 모호함을 해결했다: - * Expressions starting with `0x` are always hexadecimal literals. - * Expressions starting with a numeric literal followed by `e` or `E` are always floating-point literals. + * `0x`로 시작하는 표현식은 항상 16진수 리터럴이다. + * 수치형 리터럴으로 시작하는 표현식에서 수치형 리터럴 다음에 `e`또는 `E`가 뒤따라오면 항상 부동소수점 리터럴이다. -## Literal zero and one +## 리터럴 0과 1 -Julia provides functions which return literal 0 and 1 corresponding to a specified type or the -type of a given variable. +Julia는 어떤 특정한 타입이나 주어진 변수의 타입에 따라 리터럴 0이나 1을 리턴하는 함수를 제공한다. -| Function | Description | +| 함수 | 설명 | |:----------------- |:------------------------------------------------ | -| [`zero(x)`](@ref) | Literal zero of type `x` or type of variable `x` | -| [`one(x)`](@ref) | Literal one of type `x` or type of variable `x` | +| [`zero(x)`](@ref) | `x`타입이나 변수 `x`의 타입의 리터럴 0 | +| [`one(x)`](@ref) | `x`타입이나 변수 `x`의 타입의 리터럴 1 | -These functions are useful in [Numeric Comparisons](@ref) to avoid overhead from unnecessary -[type conversion](@ref conversion-and-promotion). +위 함수들은 [Numeric Comparisons](@ref)에서 불필요한 [type conversion](@ref conversion-and-promotion)에 의한 성능저하를 줄일 때 유용하다. Examples: From 0c78bc009c20d1b261286c56b7871fc2d4b39ae1 Mon Sep 17 00:00:00 2001 From: songnari Date: Fri, 1 Dec 2017 12:13:25 +0900 Subject: [PATCH 4/4] note translation --- src/manual/integers-and-floating-point-numbers.md | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/manual/integers-and-floating-point-numbers.md b/src/manual/integers-and-floating-point-numbers.md index d36c838..9fa78d3 100644 --- a/src/manual/integers-and-floating-point-numbers.md +++ b/src/manual/integers-and-floating-point-numbers.md @@ -534,11 +534,8 @@ julia> 2^2x julia> 2(x-1)^2 - 3(x-1) + 1 3 ``` -!!! note - The precedence of numeric literal coefficients used for implicit - multiplication is higher than other binary operators such as multiplication - (`*`), and division (`/`, `\`, and `//`). This means, for example, that - `1 / 2im` equals `-0.5im` and `6 // 2(2 + 1)` equals `1 // 1`. +!!! 중요 : + 내재적(implicit)으로 사용된 수치형 리터럴 계수의 선행은 다른 곱셈(`*`)과 나눗셈(`/`,`\`, `//`) 같은 이진 연산자보다 높습니다. 예를들어 `1/2im1`은 `-0.5im`과 같고, `6//2(2+1)`는 `1//1`과 같습니다. 게다가 괄호 표현식은 변수 또한 계수로 생각하여, 곱셈기호 없이도 변수들 간의 곱으로 식을 표현할 수도 있다: