#
msgid ""
msgstr ""
"Project-Id-Version: Modelica by Example v0.3.6\n"
"Report-Msgid-Bugs-To: mail@modelica.co.kr\n"
"POT-Creation-Date: 2023-01-28 22:37+0000\n"
"PO-Revision-Date: 2023-03-12 22:37+0000\n"
"Last-Translator: Baek Youngjin, mail@modelica.co.kr / Ha HyeonSu, <iloveyou934671@gmail.com>\n"
"Language-Team: modelica.co.kr <mail@modelica.co.k>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.6.0\n"


#: ../../source/behavior/arrays/construction.rst:4
msgid "Array Construction"
msgstr ""
"배열 구조(Array Construction)"

#: ../../source/behavior/arrays/construction.rst:6
msgid ""
"Now that we know :ref:`how to declare that a variable is an array <array-"
"declarations>`, the next step is filling in all the elements of those "
"arrays.  There are many different ways to construct arrays in Modelica."
msgstr ""
"이제  변수가 :ref:`배열임을 선언하는 방법을 알았으므로 <array-declarations>` 다음 단계는 해당 배열의 모든 요소를 채우는 것입니다."
"모델리카에서 배열을 구성하는 방법에는 여러 가지가 있습니다."


#: ../../source/behavior/arrays/construction.rst:12
msgid "Literals"
msgstr ""
"리터럴(Literals)"

#: ../../source/behavior/arrays/construction.rst:15
msgid "Vectors"
msgstr ""
" 벡터(Vectors) "


#: ../../source/behavior/arrays/construction.rst:17
msgid ""
"The simplest method for constructing an array is to enumerate each of the"
" individual elements.  For example, given the following parameter "
"declaration for a variable named ``x`` meant to represent a vector:"
msgstr ""
"배열을 구성하는 가장 간단한 방법은 각 개별 요소를 열거하는 것입니다. "
"예를 들어, 벡터를 나타내는 ``x`` 라는 변수에 대한 다음 파라미터 선언이 주어집니다."


#: ../../source/behavior/arrays/construction.rst:25
msgid ""
"When we use the term \"vector\" here, we are referring to an array that "
"has only one subscript dimension.  If we wanted to assign a value to this"
" vector, we could do so as follows:"
msgstr ""
"여기에서 "vector"라는 용어를 사용할 때 첨자 차원이 하나만 있는 배열을 참조합니다. "
"이 벡터에 값을 할당하려면 다음과 같이 할 수 있습니다."


#: ../../source/behavior/arrays/construction.rst:33
msgid ""
"Clearly, the variable ``x`` is (declared to be) a vector with three real "
"valued components.  For consistency, the right hand side must also be a "
"vector with three real valued components.  Fortunately, it is.  The "
"expression ``{1.0, 0.0, -1.0}`` is a special syntax in Modelica for "
"constructing vectors.  We can use this syntax of a pair of ``{}`` "
"containing a comma separated list of expressions to build vectors of any "
"size we wish, *e.g.,*"
msgstr ""
"분명히 변수 ``x`` 는 3개의 실수 성분을 가진 벡터입니다. "
"일관성을 위해 우변도 3개의 실수 성분이 있는 벡터여야 하는데, 다행히도 그렇습니다. "
"``{1.0, 0.0, -1.0}`` 표현식은 벡터를 구성하기 위한 모델리카의 특수 구문입니다."
"쉼표로 구분된 표현식 목록을 포함하는 한 쌍의 ``{}`` 구문을 사용하여 원하는 크기의 벡터를 만들 수 있습니다. "
"*예* 를 들면 아래와 같습니다."


#: ../../source/behavior/arrays/construction.rst:45
msgid ""
"While it is possible to use the ``{}`` notation to construct arrays of "
"any dimension, *e.g.,*"
msgstr ""
"``{}`` 표기법을 사용하여 모든 차원의 배열을 구성할 수도 있습니다. "
"예를 들면 아래와 같습니다. "


#: ../../source/behavior/arrays/construction.rst:55
msgid "Range Notation"
msgstr ""
"범위 회전(Range Notation)"

#: ../../source/behavior/arrays/construction.rst:57
msgid ""
"Modelica includes a shorthand notation for constructing vectors of "
"sequential numbers or numbers that are evenly spaced.  For example, to "
"construct a vector of integers with elements having values from 1 to 5, "
"the following syntax can be used:"
msgstr ""
"모델리카에는 일련 번호 또는 균일한 간격의 숫자로 구성된 벡터를 구성하기 위한 속기 표기법이 포함되어 있습니다."
"예를 들어 1에서 5까지의 값을 갖는 요소가 있는 정수 벡터를 구성하려면 다음 구문을 사용할 수 있습니다."


#: ../../source/behavior/arrays/construction.rst:66
msgid "The same syntax can be used to construct arrays of floating point numbers:"
msgstr ""
"동일한 구문을 사용하여 부동 소수점 숫자 배열을 구성할 수 있습니다."

#: ../../source/behavior/arrays/construction.rst:73
msgid ""
"Note, care should be taken when vectors of reals in this way since issues"
" with floating point representations may result in the vector not "
"including the final value.  The following alternatives are also available"
" (and probably more robust):"
msgstr ""
"부동 소수점 표현 문제로 인해 벡터에 최종 값이 포함되지 않을 수 있으므로 이러한 방식으로 실수 벡터를 사용할 때 주의해야 합니다. "
"다음과 같은 대안도 사용할 수 있습니다(아마도 더 강력할 것임)."


#: ../../source/behavior/arrays/construction.rst:83
msgid ""
"It is also possible to construct ranges where the interval between values"
" is not 1 by adding the \"stride\" between the first and last values.  "
"For example, all odd numbers between 3 and 9 can be represented as:"
msgstr ""
"첫 번째 값과 마지막 값 사이에 "스트라이드(stride)"를 추가하여 값 사이의 간격이 1이 아닌 범위를 구성할 수도 있습니다. "
"예를 들어, 3과 9 사이의 모든 홀수는 다음과 같이 나타낼 수 있습니다."


#: ../../source/behavior/arrays/construction.rst:92
msgid ""
"It is also possible to insert a stride value when dealing with floating "
"point numbers as well.  This range notation can also be used with an "
"``enumeration`` type (but a stride value is not permitted in that case)."
msgstr ""
"부동 소수점 숫자를 다룰 때도 사이 간격 값을 삽입할 수 있습니다."
"이 범위 표기법은 ``enumeration`` 자료형과 함께 사용할 수도 있습니다(그러나 이 경우 stride 값은 허용되지 않습니다)."


#: ../../source/behavior/arrays/construction.rst:98
msgid "Matrix Construction"
msgstr ""
"매트릭스 구성(Matrix Construction)"

#: ../../source/behavior/arrays/construction.rst:100
msgid ""
"But it is important to note that there is also a special syntax used for "
"constructing matrices (arrays with exactly two subscript dimensions).  "
"Consider the following parameter declarations with initializer:"
msgstr ""
"그러나 행렬(정확히 2개의 첨자 차원이 있는 배열)을 구성하는 데 사용하는 특수 구문도 있다는 점에 유의하는 것이 중요합니다."
"이니셜라이저를 사용한 다음 파라미터 선언을 살펴보겠습니다."


#: ../../source/behavior/arrays/construction.rst:109
msgid ""
"In this case, the parameter ``B`` is equivalent to the following in "
"mathematical notation:"
msgstr ""
"이 경우 파라미터 ``B`` 의 수학적 표기법은 다음과 같습니다."


#: ../../source/behavior/arrays/construction.rst:112
msgid ""
"B = \\left[ \\begin{array}{ccc} 1.0 & 2.0 & 3.0 \\\\ 5.0 & 6.0 & 7.0 "
"\\end{array} \\right]"
msgstr ""

#: ../../source/behavior/arrays/construction.rst:121
msgid ""
"As we can see in both the Modelica code and the more mathematical "
"representation, the matrix ``B`` has two rows and three columns.  The "
"syntax for building arrays in this way is a bit more complicated than "
"building vectors.  Superficially, we see that while a vector is "
"surrounded by ``{}``, a matrix is surrounded by ``[]``.  But more "
"importantly, a mixture of commas **and semicolons** are used as "
"delimiters.  The semicolons are used to separate rows and the commas are "
"used to separate the columns."
msgstr ""
"모델리카 코드와 수학적 표현에서 볼 수 있듯이 행렬 ``B`` 에는 2개의 행과 3개의 열이 있습니다."
"이러한 방식으로 배열을 구축하는 구문은 벡터를 구축하는 것보다 약간 더 복잡합니다."
"표면적으로 벡터는 ``{}`` 로 둘러싸여 있는 반면 행렬은 ``[]`` 로 둘러싸여 있음을 알 수 있습니다."
"그러나 더 중요한 것은 쉼표 **와 세미콜론** 이 구분 기호로 사용된다는 것입니다."
"세미콜론은 행을 구분하는 데 사용되고 쉼표는 열을 구분하는 데 사용합니다."



#: ../../source/behavior/arrays/construction.rst:130
msgid ""
"One nice feature about this matrix construction notation is that it is "
"possible to embed vectors or submatrices."
msgstr ""
"이 행렬 구성 표기법의 좋은 기능 중 하나는 벡터 또는 부분 행렬을 포함할 수 있다는 것입니다."

#: ../../source/behavior/arrays/construction.rst:135
msgid ""
"When embedding vectors, it is very important to note that **vectors are "
"treated as column vectors**.  In other words, in the context of matrix "
"construction, a vector of size :math:`n` is treated as a matrix with "
":math:`n` rows and 1 column."
msgstr ""
"벡터를 임베딩할 때 **벡터는 열 벡터로 취급** 된다는 점에 유의하는 것이 매우 중요합니다. "
"즉, 행렬 구성의 맥락에서 크기가 :math:`n` 인 벡터는 행과 1열이 있는 행렬로 취급합니다."


#: ../../source/behavior/arrays/construction.rst:140
msgid ""
"To demonstrate how this embedding is done, consider the case where we "
"wished to construct the following matrix:"
msgstr ""
"이 임베딩이 수행되는 방법을 보여주기 위해 다음 행렬을 구성하려는 경우를 살펴 보겠습니다."


#: ../../source/behavior/arrays/construction.rst:143
msgid ""
"C = \\left[ \\begin{array}{ccc} \\left| \\begin{array}{cc} 2 & 1 \\\\ 1 &"
" 2 \\end{array} \\right| & \\left| \\begin{array}{cc} 0 & 0 \\\\ 0 & 0 "
"\\end{array} \\right| & \\left| \\begin{array}{cc} 0 & 0 \\\\ 0 & 0 "
"\\end{array} \\right| \\\\ \\left| \\begin{array}{cc} 0 & 0 \\\\ 0 & 0 "
"\\end{array} \\right| & \\left| \\begin{array}{cc} 2 & 1 \\\\ 1 & 2 "
"\\end{array} \\right| & \\left| \\begin{array}{cc} 0 & 0 \\\\ 0 & 0 "
"\\end{array} \\right| \\\\ \\left| \\begin{array}{cc} 0 & 0 \\\\ 0 & 0 "
"\\end{array} \\right| & \\left| \\begin{array}{cc} 0 & 0 \\\\ 0 & 0 "
"\\end{array} \\right| & \\left| \\begin{array}{cc} 2 & 1 \\\\ 1 & 2 "
"\\end{array} \\right| \\end{array} \\right]"
msgstr ""

#: ../../source/behavior/arrays/construction.rst:204
msgid ""
"We can do this concisely in Modelica by first creating each of the "
"submatrices and then filling in :math:`C` using these submatrices as "
"follows:"
msgstr ""
"먼저 각 부분 행렬을 만든 다음 다음과 같이 이러한 부분 행렬을 사용하여 :math:`C` 를 채워서 "
"모델리카에서 이 작업을 간결하게 수행할 수 있습니다."


#: ../../source/behavior/arrays/construction.rst:216
msgid ""
"In other words, the ``,`` and ``;`` delimiters work with either scalars "
"or submatrices."
msgstr ""
"즉, ``,`` 및 ``;`` 구분 기호는 스칼라 또는 부분 행렬과 함께 작동합니다."



#: ../../source/behavior/arrays/construction.rst:219
msgid ""
"As we will see shortly, there are several different :ref:`array-"
"construction-functions` that can be extremely useful when building "
"matrices in this way."
msgstr ""
"곧 보게 되겠지만, 이러한 방식으로 행렬을 만들 때 매우 유용할 수 있는 몇 가지 다른 배열 구성 함수가 있습니다.""

#: ../../source/behavior/arrays/construction.rst:224
msgid "Arrays of Any Size"
msgstr ""
"임의의 크기의 배열(Arrays of Any Size)"

#: ../../source/behavior/arrays/construction.rst:226
msgid ""
"So far, we've discussed vectors and matrices.  But you can construct "
"arbitrary arrays with any number of dimensions (including vectors and "
"matrices) using by constructing them as a series of nested vectors. For "
"example, to construct an array with three dimensions, we could simply "
"nested a collection of vectors as follows:"
msgstr ""
"지금까지 벡터와 행렬에 대해 논의했습니다. "
"그러나 배열을 일련의 중첩된 벡터로 구성하여 임의 개수의 차원(벡터 및 행렬 포함)을 사용하여 임의의 배열을 구성할 수 있으며,"
"예를 들어 3차원 배열을 구성하려면 다음과 같이 벡터 컬렉션을 간단히 중첩할 수 있습니다."


#: ../../source/behavior/arrays/construction.rst:241
msgid ""
"As can be seen in this example, the inner most elements in this nested "
"construction correspond to the right most dimension in the declaration.  "
"In other words, the array here is a vector containing two elements where "
"each of those two elements is a vector containing three elements and each"
" of those three elements is a vector of 4 scalars."
msgstr ""
"이 예제에서 볼 수 있듯이 이 중첩 구성에서 가장 안쪽에 있는 요소는 선언에서 가장 오른쪽 차원에 해당합니다. "
"즉, 여기서 배열은 두 개의 요소를 포함하는 벡터입니다. "
"여기서 각 두 요소는 세 개의 요소를 포함하는 벡터이고 각 세 요소는 4개의 스칼라로 구성된 벡터입니다."


#: ../../source/behavior/arrays/construction.rst:251
msgid "Array Comprehensions"
msgstr ""
"배열 내포(Array Comprehensions)"

#: ../../source/behavior/arrays/construction.rst:253
msgid ""
"So far, we've shown how to construct vectors, matrices and higher "
"dimensional arrays by enumerating the elements contained in the array. As"
" we can see in the case of higher dimensional arrays, these constructions"
" can get very complicated.  Fortunately, Modelica includes array "
"comprehensions which provide a convenient syntax for programmatically "
"constructing arrays."
msgstr ""
"지금까지 배열에 포함된 요소를 열거하여 벡터, 행렬 및 고차원 배열을 구성하는 방법을 살펴보았습니다."
"고차원 배열의 경우에서 볼 수 있듯이 이러한 구조는 매우 복잡해질 수 있습니다."
"다행스럽게도 모델리카에는 프로그래밍 방식으로 배열을 구성하기 위한 편리한 구문을 제공하는 배열 이해 기능이 포함되어 있습니다."
 
#: ../../source/behavior/arrays/construction.rst:260
msgid ""
"The use of array comprehensions has several benefits.  The first is that "
"it is a much more compact notation.  The second is that it allows us to "
"easily express how the values in the array are tied to the various "
"indices.  The third is that it can be done in a context where an "
"expression is required (typically providing values for variables in "
"variable declarations).  Finally, some tools may find it easier to "
"optimize array comprehensions."
msgstr ""
"배열 내포를 사용하면 몇 가지 이점이 있습니다."
"첫 번째는 훨씬 더 간결한 표기법이라는 것이며, 두 번째는 배열의 값이 다양한 인덱스에 연결되는 방식을 쉽게 표현할 수 있다는 것입니다. "
"세 번째는 표현식이 필요한 컨텍스트에서 수행할 수 있다는 것입니다(일반적으로 변수 선언에서 변수에 대한 값 제공). "
"마지막으로 일부 시뮬레이션 소프트웨어는 배열 이해를 최적화하는 것이 더 쉬울 수 있습니다."



#: ../../source/behavior/arrays/construction.rst:267
msgid ""
"To demonstrate array comprehensions, consider the following relationship "
"between elements in an array and the indices of the array:"
msgstr ""
"배열 내포를 시연하려면 배열의 요소와 배열 인덱스 사이의 다음 관계를 고려 해야 합니다."

#: ../../source/behavior/arrays/construction.rst:271
msgid "a_{ijk} = i\\ x_j\\ y_k"
msgstr ""

#: ../../source/behavior/arrays/construction.rst:275
msgid ""
"where :math:`x` and :math:`y` are vectors.  We've already seen how we "
"could recursively define such an array using a series of nested vectors."
"  But we have also seen how long such an expression could potentially be "
"and how tedious it is to read and write.  Using array comprehensions, we "
"can construct the :math:`a` array quite easily as:"
msgstr ""
"여기서 :math:`x` 및 :math:`y` 는 벡터입니다. "
"일련의 중첩된 벡터를 사용하여 이러한 배열을 재귀적으로 정의하는 방법을 이미 살펴보았습니다."
"그러나  또한 그러한 표현이 잠재적으로 얼마나 오래 걸릴 수 있고 읽고 쓰는 것이 얼마나 지루한지 보았습니다."
"배열 내포를 사용하면 다음과 같이 매우 쉽게 :math:`a` 배열을 구성할 수 있습니다."


#: ../../source/behavior/arrays/construction.rst:287
msgid ""
"This code builds an array with 1800 elements with only a few lines of "
"Modelica code."
msgstr ""
"이 코드는 몇 줄의 모델리카 코드만으로 1800개의 요소로 배열을 만듭니다."


#~ msgid ""
#~ "So far, we've shown how to "
#~ "construct vectors, matrices and higher "
#~ "dimensional arrays by enumerating the "
#~ "elements contained in the array. As "
#~ "we can see in the case of "
#~ "higher dimensional arrays, these constructions"
#~ " can get very complicated.  Fortunately,"
#~ " Modelica includes array comprehensions "
#~ "which provide a convenient syntax for"
#~ " programmatically constructing arrays.  This "
#~ "approach has two main benefits.  The "
#~ "first is that it is a much "
#~ "more compact notation.  The second is"
#~ " that it allows us to easily "
#~ "express how the values in the "
#~ "array are tied to the various "
#~ "indices."
#~ msgstr ""

