#
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/functions/interpolation.rst:4
#: ../../source/behavior/functions/interpolation.rst:310
msgid "Interpolation"
msgstr ""
"보간(Interpolation)"

#: ../../source/behavior/functions/interpolation.rst:6
msgid ""
"In this chapter, we will example different ways of implementing a simple "
"one dimension interpolation scheme.  We'll start with an approach that is"
" written completely in Modelica and then show an alternative "
"implementation that combines Modelica with C.  The advantages and "
"disadvantages of each approach will then be discussed."
msgstr ""
"이 장에서는 간단한 1차원 보간 방식을 구현하는 다양한 방법을 예로 들어 보겠습니다."
"모델리카 만으로 작성된 방식으로 시작한 다음 모델리카와 C를 결합한 대체 방법으로 구현한 것을 살펴 보겠습니다. "
"그런 다음 각 접근 방식의 장점과 단점에 대해 설명합니다."


#: ../../source/behavior/functions/interpolation.rst:13
msgid "Modelica Implementation"
msgstr ""
"모델리카로 구현(Modelica Implementation)"

#: ../../source/behavior/functions/interpolation.rst:16
msgid "Function Definition"
msgstr ""
"함수의 정의(Function Definition)"

#: ../../source/behavior/functions/interpolation.rst:18
msgid ""
"For this example, we assume that we interpolate data in the following "
"form:"
msgstr ""
"이 예제에서는 데이터를 다음 형식으로 보간한다고 가정합니다."

#: ../../source/behavior/functions/interpolation.rst:22
msgid "Independent Variable, :math:`x`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:22
msgid "Dependent Variable, :math:`y`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:24
msgid ":math:`x_1`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:24
msgid ":math:`y_1`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:25
msgid ":math:`x_2`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:25
msgid ":math:`y_2`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:26
msgid ":math:`x_3`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:26
msgid ":math:`y_3`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:27
msgid "..."
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:28
msgid ":math:`x_n`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:28
msgid ":math:`y_n`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:31
msgid "where we assume that :math:`x_i<x_{i+1}`."
msgstr ""
"이 데이터는 :math:`x_i<x_{i+1}` 라고 가정 하겠습니다.  "

#: ../../source/behavior/functions/interpolation.rst:33
msgid ""
"Given this data and the value for the independent variable :math:`x` that"
" we are interested in, our function should return an interpolated value "
"for :math:`y`.  Such a function could be implemented in Modelica as "
"follows:"
msgstr ""
"데이터에서 독립 변수 :math:`x` 의 값이 주어지면 함수는 :math:`y` 에 대해 보간된 값을 반환해야 합니다."
"이러한 기능은 모델리카에서 다음과 같이 구현될 수 있습니다."


#: ../../source/behavior/functions/interpolation.rst:42
msgid ""
"Let's go through this function piece by piece to understand what is going"
" on.  We'll start with the argument declarations:"
msgstr ""
"이 기능을 하나씩 살펴보고 무슨 일이 일어나고 있는지 이해해 보겠습니다."
"인자(argument) 선언부터 알아보겠습니다. "


#: ../../source/behavior/functions/interpolation.rst:49
msgid ""
"The ``input`` argument ``x`` represents the value of the independent "
"variable we wish to use for interpolating our function, the ``input`` "
"argument ``ybar`` represents the interpolation data and the ``output`` "
"argument ``y`` represents the interpolated value.  The next part of the "
"function contains:"
msgstr ""
"``input`` 전달 인자(argument) ``x`` 는 함수를 보간에 사용하려는 독립 변수의 값을 나타내고 ``input`` 전달 인자 ``ybar`` 는 보간 데이터를 나타내며 "
"``output`` 전달 인자 ``y`` 는 보간된 값을 나타냅니다. "
"함수의 다음 구문을 살펴보겠습니다."


#: ../../source/behavior/functions/interpolation.rst:59
msgid ""
"The part of our function includes the declaration of various "
"``protected`` variables.  As we saw in our :ref:`polynomial-evaluation` "
"example, these are effectively intermediate variables used internally by "
"the function.  In this case, ``i`` is going to be used as an index "
"variable, ``n`` is the number of data points in our interpolation data "
"and ``p`` represents a weight used in our interpolation scheme."
msgstr ""
"다양한 ``protected`` 변수의 선언이 되어 있으며, :ref:`polynomial-evaluation` 예제에서 보았듯이 이 변수들은 함수에 의해 내부적으로 사용하는 사실상 매개 변수입니다. "
"이 경우 ``i`` 는 인덱스 변수로 사용되고 ``n`` 은 보간 데이터의 데이터 포인트 수이며 ``p`` 는 보간 방식에 사용하는 가중치를 나타냅니다."


#: ../../source/behavior/functions/interpolation.rst:67
msgid ""
"With all the variable declarations out of the way, we can now implement "
"the ``algorithm`` section of our function:"
msgstr ""
"모든 변수 선언이 완료 되었으므로, 이제 함수의 ``algorithm`` 섹션을 구현할 수 있습니다."

#: ../../source/behavior/functions/interpolation.rst:74
msgid ""
"The first two statements are ``assert`` statements that verify that the "
"value of ``x`` is within the interval :math:`[x_1, x_n]`.  If not, an "
"error message will be generated explaining why the interpolation failed."
msgstr ""
"처음 두 문장은 ``x`` 값이 :math:`[x_1, x_n]` 간격 내에 있는지 확인하는 ``assert`` 문장입니다. "
"그렇지 않은 경우 보간이 실패한 이유를 설명하는 오류 메시지가 생성됩니다."



#: ../../source/behavior/functions/interpolation.rst:79
msgid ""
"The rest of the function searches for the value of ``i`` such that "
":math:`x_i<=x<x_{i+1}`.  Once that value of ``i`` has been identified, "
"the interpolated value is computed as simply:"
msgstr ""
"나머지 함수는 :math:`x_i<=x<x_{i+1}` 과 같은 ``i`` 값을 검색합니다."
"``i`` 값이 식별되면 보간된 값은 다음과 같이 간단하게 계산합니다."

#: ../../source/behavior/functions/interpolation.rst:83
msgid "y = p\\ \\bar{y}_{i+1,2}+(1-p)\\ \\bar{y}_{i,2}"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:87
msgid "where"
msgstr ""
"이를 다시 정리하면 아래와 같은 수식을 얻습니다."

#: ../../source/behavior/functions/interpolation.rst:89
msgid "p = \\frac{x-\\bar{y}_{i,1}}{\\bar{y}_{i+1,1}-\\bar{y}_{i,1}]}"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:94
#: ../../source/behavior/functions/interpolation.rst:163
msgid "Test Case"
msgstr ""
"테스트 케이스(Test Case)"

#: ../../source/behavior/functions/interpolation.rst:96
msgid ""
"Now, let's test this function by using it from within a model.  As a "
"simple test case, let's integrate the value returned by the interpolation"
" function.  We'll use the following data as the basis for our function:"
msgstr ""
"이제 이 기능을 모델 내에서 사용하여 테스트해 보겠습니다. "
"간단한 테스트 사례로 보간 함수에서 반환한 값을 적분 하는 것으로 검증하는 것 입니다."
"다음 데이터를 이용해서  기능을 검증하는 기초 데이터로 사용하겠습니다."


#: ../../source/behavior/functions/interpolation.rst:102
msgid ":math:`x`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:102
msgid ":math:`y`"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:104
#: ../../source/behavior/functions/interpolation.rst:105
#: ../../source/behavior/functions/interpolation.rst:107
#: ../../source/behavior/functions/interpolation.rst:108
msgid "0"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:105
#: ../../source/behavior/functions/interpolation.rst:106
msgid "2"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:106
msgid "4"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:107
msgid "6"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:108
msgid "8"
msgstr ""

#: ../../source/behavior/functions/interpolation.rst:111
msgid ""
"If we plot this data, we see that our interpolated function looks like "
"this:"
msgstr ""
"이 데이터를 선도로 표현하면 보간된 함수가 다음과 같이 표시됩니다."

#: ../../source/behavior/functions/interpolation.rst:125
msgid ""
"In the following model, the independent variable ``x`` is set equal to "
"``time``.  The sample data is then used to interpolate a value for the "
"variable ``y``.  The value of ``y`` is then integrated to compute ``z``."
msgstr ""
"다음 모델에서 독립 변수 ``x`` 는 ``time`` 과 동일하게 설정 하며, 샘플 데이터는 변수 ``y`` 에 대한 값을 보간하는 데 사용합니다. "
"그런 다음 ``y`` 값을 통합하여 ``z`` 를 계산합니다."


#: ../../source/behavior/functions/interpolation.rst:134
msgid "We can see the simulated results from this model in the following plot:"
msgstr ""
"다음 플롯에서 이 모델의 시뮬레이션 결과를 볼 수 있습니다."

#: ../../source/behavior/functions/interpolation.rst:139
msgid ""
"There are a couple of drawbacks to this approach.  The first is that the "
"data needs to be passed around anywhere the function is used. Also, for "
"higher dimensional interpolation schemes, the data required can be both "
"complex (for irregular grids) and large.  So it is not necessarily "
"convenient to store the data in the Modelica source code. For example, it"
" might be preferable to store the data in an external file.  However, to "
"populate the interpolation data from a source other than the Modelica "
"source code, we will need to use an ``ExternalObject``."
msgstr ""
"이 접근 방식에는 몇 가지 단점이 있습니다. "
"첫 번째는 함수가 사용하는 모든 곳에 데이터를 전달해야 한다는 것입니다. "
"또한 더 높은 차원의 보간 방식의 경우 필요한 데이터가 복잡하고(불규칙한 그리드의 경우) 클 수 있습니다."
"따라서 모델리카 소스 코드에 데이터를 저장하는 것이 반드시 편리한 것은 아니기 때문에, 예를 들어 데이터를 외부 파일에 저장하는 것이 더 나을 수 있습니다. "
"그러나 모델리카 소스 코드 이외의 소스에서 보간 데이터를 채우려면 ``ExternalObject`` 를 사용해야 합니다."


#: ../../source/behavior/functions/interpolation.rst:150
msgid "Using an ``ExternalObject``"
msgstr ""
"``ExternalObject`` 사용하기(Using an ``ExternalObject``)"

#: ../../source/behavior/functions/interpolation.rst:154
msgid ""
"The ``ExternalObject`` type is a special type used to refer to "
"information that is not (necessarily) represented in the Modelica source "
"code.  The main use of the ``ExternalObject`` type is to represent data "
"or state that is maintained outside the Modelica source code.  This might"
" be interpolation data, as we will see in a moment, or it might represent"
" some other software system that maintains its own state."
msgstr ""
"``ExternalObject`` 타입은 (당연하게도) 모델리카 소스 코드에 표현되지 않은  정보를 참조하는 데 사용하는 특수 유형입니다. "
"``ExternalObject`` 타입의 주요 용도는 모델리카 소스 코드 외부에서 유지되는 데이터 또는 상태를 나타내는 것입니다."
"이것은  곧 보게 될 보간 데이터일 수도 있고 자체 상태를 유지하는 다른 소프트웨어 시스템을 나타내는 것일 수도 있습니다."


#: ../../source/behavior/functions/interpolation.rst:165
msgid ""
"For this example, we will flip things around and start with the test "
"case.  This will provide some useful context about how an "
"``ExternalObject`` is used.  The Modelica source code for our test case "
"is:"
msgstr ""
"이 예제에서는 앞서 설명한 방식과 상황을 뒤집어 테스트 사례부터 시작하겠습니다. "
"이것은 ``ExternalObject`` 가 어떻게 사용하는지에 대한 몇 가지 유용한 컨텍스트를 제공할 것입니다."
"테스트 케이스의 모델리카 소스 코드는 다음과 같습니다."


#: ../../source/behavior/functions/interpolation.rst:174
msgid ""
"Here the main difference between this and our previous test case is the "
"fact that we don't pass our data directly into the interpolation "
"function.  Instead, we create a special variable ``vector`` whose type is"
" ``VectorTable``.  We'll discuss exactly what a ``VectorTable`` is in a "
"moment.  But for now think of it as something that represents (only) our "
"interpolation data.  Other than the creation of the ``vector`` object, "
"the rest of the model is virtually identical to the previous case except "
"that we use the ``InterpolateExternalVector`` function to perform our "
"interpolation and we pass the ``vector`` variable into that function in "
"place of our raw interpolation data."
msgstr ""
"여기에서 이전 테스트 케이스와 주요 차이점은 데이터를 보간 함수에 직접 전달하지 않는다는 사실입니다. "
"대신, 자료형이 ``VectorTable`` 인 특수 변수 ``vector`` 를 생성합니다. "
"곧 ``VectorTable`` 이 무엇인지 정확히 논의할 예정이기 때문에, 지금은 보간 데이터를 나타낸다고 만 생각하겠습니다."
"``vector`` 객체 생성을 제외하고 모델의 나머지 부분은 ``InterpolateExternalVector`` 함수를 사용하여 보간을 수행하고,  원시 보간 데이터 대신 해당 함수에 ``vector`` 변수를 전달한다는 점을 제외하면 이전 사례와 거의 동일합니다. "



#: ../../source/behavior/functions/interpolation.rst:185
msgid ""
"Simulating this model, we see that the results are exactly what we would "
"expect when compared to our previous test case:"
msgstr ""
"이 모델을 시뮬레이션하면 결과가 이전 테스트 사례와 비교할 때 예상했던 것과 정확히 일치함을 알 수 있습니다."

#: ../../source/behavior/functions/interpolation.rst:192
msgid "Defining an ``ExternalObject``"
msgstr ""
"``ExternalObject`` 정의하기(Defining an ``ExternalObject``)"

#: ../../source/behavior/functions/interpolation.rst:194
msgid ""
"To see how this most recent test case is implemented, we'll first look at"
" how the ``VectorTable`` type is implemented.  As mentioned previously, "
"the ``VectorTable`` is an ``ExternalObject`` type.  This is a special "
"type in Modelica that is used to represent what is often called an "
"\"opaque\" pointer.  This means that the ``ExternalObject`` represents "
"some data that is not directly accessible (from Modelica)."
msgstr ""
"무엇보다 먼저 검증한 시험 사례가 어떻게 구현되었는지 확인하기 위해, ``VectorTable`` 자료형이 어떻게 구현되었는지 살펴보겠습니다. "
"언급했듯이 ``VectorTable`` 은 ``ExternalObject`` 자료형입니다. "
"이것은 종종 "불투명(opaque,완전히 정이되어 있지 않은 상태)" 포인터라고 하는 것을 나타내는 데 사용하는 모델리카의 특수 자료형입니다."
"이는 ``ExternalObject`` 가 (모델리카에서) 직접 액세스할 수 없는 일부 데이터를 나타냄을 의미합니다."



#: ../../source/behavior/functions/interpolation.rst:201
msgid "In our case, we implement our ``VectorTable`` type as:"
msgstr ""
"``VectorTable`` 자료형을 다음과 같이 구현합니다."



#: ../../source/behavior/functions/interpolation.rst:207
msgid ""
"Note that the ``VectorTable`` inherits from the ``ExternalObject`` type."
"  An ``ExternalObject`` can have two special functions implemented inside"
" its definition, the ``constructor`` function and the ``destructor`` "
"function.  Both of these functions are seen here."
msgstr ""
"``VectorTable`` 은 ``ExternalObject`` 자료형에서 상속된다는 점을 생각해 봐야 합니다. "
"``ExternalObject`` 는 정의 내에서 구현된 ``constructor`` 함수와 ``destructor`` 함수라는 "
"두 가지 특수 함수를 가질 수 있습니다. 이 두 기능 모두 여기에 표시됩니다."


#: ../../source/behavior/functions/interpolation.rst:213
msgid "Constructor"
msgstr ""
"생성자(Constructor)"

#: ../../source/behavior/functions/interpolation.rst:215
msgid ""
"The ``constructor`` function is invoked when an instance of a "
"``VectorTable`` is created (*e.g.,* the declaration of the ``vector`` "
"variable in our test case).  This ``constructor`` function is used to "
"initialize our opaque pointer.  Whatever data is required as part of that"
" initialization process should be passed as argument to the "
"``constructor`` function.  That same data should be present during "
"instantiation (*.e.g,* the ``data`` argument in our declaration of the "
"``vector`` variable)."
msgstr ""
"``constructor`` 함수는 ``VectorTable`` 인스턴스가 생성될 때 호출됩니다"
"(*예:* 테스트 사례에서 ``vector`` 변수의 선언). "
"이 ``constructor`` 함수는 불투명 포인터를 초기화하는 데 사용합니다. "
"초기화 프로세스의 일부로 필요한 데이터는 무엇이든 ``constructor`` 함수에 대한 인수로 전달되어야 합니다. "
"동일한 데이터가 인스턴스화 중에 존재해야 합니다(*예를들어,* ``vector`` 변수 선언의 ``데이터`` 인자)."


#: ../../source/behavior/functions/interpolation.rst:224
msgid ""
"The definition of the ``constructor`` function is unusual because, unlike"
" our previous examples, it does not include an ``algorithm`` section.  "
"The ``algorithm`` section is normally used to compute the return value of"
" the function.  Instead, the ``constructor`` function has an ``external``"
" clause.  This indicates that the function is implemented in some other "
"language besides Modelica.  In this case, that other language is C (as "
"indicated by the ``\"C\"`` following the ``external`` keyword).  This "
"tells use that the ``table`` variable (which is the ``output`` of this "
"function and represents the opaque pointer) is returned by a C function "
"named ``createVectorTable`` which is passed the contents and size of the "
"``ybar`` variable."
msgstr ""
"``constructor`` 함수의 정의는 이전 예제와 달리 ``algorithm`` 섹션을 포함하지 않기 때문에 일반적이지 않습니다. "
"``algorithm`` 섹션은 일반적으로 함수의 반환 값을 계산하는 데 사용하는데, 그 대신에 ``constructor`` 함수에는 ``external`` 절이 있습니다. "
"이는 모델리카 이외의 다른 언어로 기능이 구현되었음을 나타냅니다. "
"이 경우 다른 언어는 C입니다(``external`` 키워드 다음에 나오는 ``"C"`` 로 표시됨)."
"이것은 ``table`` 변수(이 함수의 ``출력`` 이며 불투명한 포인터를 나타냄)가"
"``createVectorTable`` 이라는 C 함수와 ``ybar`` 변수의 크기에 의해 반환된다는 것을 알려줍니다. "



#: ../../source/behavior/functions/interpolation.rst:236
msgid ""
"Following the call to ``createVectorTable`` is an ``annotation``. This "
"annotation tells the Modelica compiler where to find the source code for "
"this external C function."
msgstr ""
"``createVectorTable`` 호출 다음에는 ``annotation`` 이 있습니다. "
"이 주석은 이 외부 C 함수의 소스 코드를 찾을 위치를 모델리카 컴파일러에 알려줍니다."


#: ../../source/behavior/functions/interpolation.rst:240
msgid ""
"The essential point here is that from the point of view of the Modelica "
"compiler, a ``VectorTable`` is just an opaque pointer returned by "
"``createVectorTable``.  It is not possible to access the data behind this"
" pointer from Modelica.  But this pointer can be passed to other "
"functions, as we shall see in a minute, that are also implemented in C "
"and which do know how to access the data represented by the "
"``VectorTable``."
msgstr ""
"여기서 중요한 점은 모델리카 컴파일러의 관점에서 볼 때 ``VectorTable`` 은 ``createVectorTable`` 에 의해 반환된 불투명한 포인터일 뿐이라는 것입니다. "
"모델리카에서 이 포인터 뒤에 있는 데이터에 액세스하는 것은 불가능합니다. "
'그러나 이 포인터는 C로 구현되고 ``VectorTable`` 로 표시되는 데이터에 액세스하는 방법을 알고 있는 다른 함수에 전달될 수 있습니다."


#: ../../source/behavior/functions/interpolation.rst:249
msgid "Destructor"
msgstr ""
"소멸자(Destructor)"

#: ../../source/behavior/functions/interpolation.rst:251
msgid ""
"The ``destructor`` function is invoked whenever the ``ExternalObject`` is"
" no longer needed.  This allows the Modelica runtime to clean up any "
"memory consumed by the ``ExternalObject``.  An ``ExternalObject`` "
"instantiated in a model will generally persist until the end of the "
"simulation.  But an ``ExternalObject`` declared as a ``protected`` "
"variable in a function, for example, may be created and destroyed in the "
"course of a single expression evaluation.  For that reason, it is "
"important to make sure that any memory allocated by the "
"``ExternalObject`` is released."
msgstr ""
"``destructor`` 함수는 ``ExternalObject`` 가 더 이상 필요하지 않을 때마다 호출됩니다. "
"이렇게 하면 모델리카 런타임이 ``ExternalObject`` 에서 사용하는 메모리를 정리할 수 있습니다. "
"모델에서 인스턴스화된 ``ExternalObject`` 는 일반적으로 시뮬레이션이 끝날 때까지 지속됩니다. "
"그러나 예를 들어 함수에서 ``protected`` 변수로 선언된 ``ExternalObject`` 는 단일 표현식 해석 과정에서 생성되고 소멸될 수 있습니다."
"따라서 ``ExternalObject`` 에 의해 할당된 메모리가 해제되었는지 확인하는 것이 중요합니다."


#: ../../source/behavior/functions/interpolation.rst:261
msgid ""
"In general, the ``destructor`` function is also implemented as an "
"external function.  In this case, calling the ``destructor`` function "
"from Modelica invokes the C function ``destroyVectorTable`` which is "
"passed a ``VectorTable`` instance as an argument.  Any memory associated "
"with that ``VectorTable`` instance should be freed by the call to "
"``destructor``.  Again, we see the same types of annotations used to "
"inform the Modelica compiler where to find the source code for the "
"``destoryVectorTable`` function."
msgstr ""
"일반적으로 ``destructor`` 함수는 외부 함수로도 구현됩니다. "
"이 경우 모델리카에서 ``destructor`` 함수를 호출하면 ``VectorTable`` 인스턴스가 인수로 전달되는 C 함수 ``destroyVectorTable`` 이 호출됩니다. "
"해당 ``VectorTable`` 인스턴스와 관련된 모든 메모리는 ``destructor`` 호출로 해제되어야 합니다. "
"다시, ``destoryVectorTable`` 함수의 소스 코드를 찾을 위치를 모델리카 컴파일러에 알리는 데 사용하는 동일한 자료형의 annotations을 볼 수 있습니다."


#: ../../source/behavior/functions/interpolation.rst:271
msgid "External C Code"
msgstr ""
"외부 C 코드(External C Code)"

#: ../../source/behavior/functions/interpolation.rst:273
msgid "These external C functions are implemented as follows:"
msgstr ""
"이전의 예제에서 호출했던 외부 C 함수는 다음과 같이 구현됩니다."

#: ../../source/behavior/functions/interpolation.rst:278
msgid ""
"This is not a book on the C programming language so an exhaustive review "
"of this code and exactly how it functions is beyond the scope of the "
"book.  But we can summarize the contents of this file as follows."
msgstr ""
"이 책은 C 프로그래밍 언어에 관한 책이 아니므로 이 코드에 대한 철저한 검토와 코드가 정확히 어떻게 작동하는지에 대해서 다루는 것은 책의 범위를 벗어납니다."
"하지만 이 파일의 내용을 다음과 같이 요약할 수 있습니다."


#: ../../source/behavior/functions/interpolation.rst:283
msgid ""
"First, the ``struct`` called ``VectorTable`` is the data associated wit "
"the ``VectorTable`` type in Modelica.  This includes not just the "
"interpolation data (in the form of the ``x`` and ``y`` members), but also"
" the number of data points, ``npoints``, and a cached value for the last "
"used index, ``lastIndex``."
msgstr ""
"먼저 ``VectorTable`` 이라는 ``struct`` 는 모델리카에서 ``VectorTable`` 자료형과 관련된 데이터입니다. "
"여기에는 보간 데이터(``x`` 및 ``y`` 멤버 형식)뿐만 아니라 데이터 포인트 수 ``npoints`` 및 마지막으로 사용된 인덱스에 대해 캐시된 값 ``lastIndex`` 도 포함됩니다."


#: ../../source/behavior/functions/interpolation.rst:289
msgid ""
"Next, we see the ``createVectorTable`` function which allocates an "
"instance of the ``VectorTable`` structure and initializes all the data "
"inside it.  That instance is then returned to the Modelica runtime. "
"Following the definition of ``createVectorTable`` is the definition of "
"``destroyVectorTable`` which effectively undoes what was done by "
"``createVectorTable``."
msgstr ""
"다음으로 ``VectorTable`` 구조의 인스턴스를 할당하고 그 안의 모든 데이터를 초기화하는 ``createVectorTable`` 함수를 보면, 해당 인스턴스가 모델리카 런타임으로 반환 되는 것을 알 수 있습니다."
"``createVectorTable`` 정의 다음에는 ``createVectorTable`` 에 의해 수행된 작업을 효과적으로 취소하는 ``destroyVectorTable`` 정의가 있습니다."


#: ../../source/behavior/functions/interpolation.rst:296
msgid ""
"Finally, we see the function ``interpolateVectorTable``.  This is a C "
"function that is passed an instance of the ``VectorTable`` structure and "
"a value for the independent variable and returns the interpolated value "
"for the dependent variable.  This function performs almost exactly the "
"same function as the ``InterpolateVector`` function presented earlier.  "
"The Modelica runtime provides functions like ``ModelicaFormatError`` so "
"that external C code can report errors.  In the case of "
"``interpolateVectorTable``, these functions are used to implement the "
"assertions we saw previously in ``InterpolateVector``. The lookup of "
"``i`` is basically the same except that instead of starting from 1 each "
"time, it starts from the value of ``i`` found in the last call to "
"``interpolateVectorTable``."
msgstr ""
"마지막으로 ``interpolateVectorTable`` 함수를 보겠습니다. "
"이것은 ``VectorTable`` 구조의 인스턴스와 독립 변수에 대한 값을 전달하고 종속 변수에 대한 보간된 값을 반환하는 C 함수인데, "
"앞에서 제시한 ``InterpolateVector`` 함수와 거의 동일한 기능을 수행합니다. "
"모델리카 런타임은 외부 C 코드가 오류를 보고할 수 있도록 ``ModelicaFormatError`` 와 같은 기능을 제공합니다. "
"``interpolateVectorTable`` 함수는 이전에 ``InterpolateVector`` 에서 보았던 내용을 구현하는 데 사용합니다. "
"``i`` 조회는 매번 1부터 시작하는 대신 ``interpolateVectorTable`` 에 대한 마지막 호출에서 찾은 ``i`` 값에서 시작한다는 점을 제외하면 기본적으로 동일합니다."


#: ../../source/behavior/functions/interpolation.rst:312
msgid ""
"We've seen how ``interpolateVectorTable`` is defined, but so far we "
"haven't seen where it is used.  We mentioned that performs very much the "
"same role as ``InterpolateVector``, but using a ``VectorTable`` object to"
" represent the interpolation data.  To invoke ``interpolateVectorTable`` "
"from Modelica, we simple need to define a Modelica function as follows:"
msgstr ""
"``interpolateVectorTable`` 이 어떻게 정의되는지 보았지만 지금까지 그것이 어디에 사용하는지는 보지 못했습니다. "
"``InterpolateVector`` 와 거의 같은 역할을 수행하지만, ``VectorTable`` 객체를 사용하여 보간 데이터를 표현한다고 언급했습니다. "
"모델리카에서 ``interpolateVectorTable`` 을 호출하려면 다음과 같이 모델리카 함수를 정의하기만 하면 됩니다."


#: ../../source/behavior/functions/interpolation.rst:323
msgid ""
"We mentioned previously that ``VectorTable`` is opaque and that Modelica "
"code cannot access the data contained in the ``VectorTable``.  The "
"Modelica function ``InterpolateExternalVector`` invokes its C counterpart"
" ``interpolateVectorTable`` which **can** access the interpolation data "
"and, therefore, perform the interpolation."
msgstr ""
"이전에 ``VectorTable`` 이 불투명하고 모델리카 코드가 ``VectorTable`` 에 포함된 데이터에 액세스할 수 없다고 언급했습니다. "
"모델리카 함수 ``InterpolateExternalVector`` 는 보간 데이터에 **접근** 할 수 있는 C 대응 ``interpolateVectorTable`` 을 호출하여 보간을 수행합니다."


#: ../../source/behavior/functions/interpolation.rst:330
msgid "Discussion"
msgstr ""
"논의(Discussion)"

#: ../../source/behavior/functions/interpolation.rst:332
msgid ""
"As was discussed previously, the initial interpolation approach required "
"us to pass around large amounts of unwieldy data.  By implementing the "
"``VectorTable``, we were able to represent that data by a single "
"variable."
msgstr ""
"이전에 논의한 바와 같이 초기 보간 방식에서는 다루기 힘든 많은 양의 데이터를 전달해야 했습니다. "
"``VectorTable`` 을 구현함으로써  그 데이터를 단일 변수로 나타낼 수 있었습니다."


#: ../../source/behavior/functions/interpolation.rst:337
msgid ""
"An important thing to note about the ``ExternalObject`` approach, which "
"isn't adequately explored in our example, is that the initialization data"
" can be completely external to the Modelica source code.  For simplicity,"
" the example code shown in this section initializes the ``VectorTable`` "
"using an array of data.  **But it could just as easily have passed a file"
" name** to the initialization code.  That file could then have been read "
"by the ``createVectorTable`` function and the contents of the "
"``VectorTable`` structure could have been initialized using the data from"
" that file. In many cases, this approach not only makes managing the data"
" easier, but leveraging C allows more complex (new or existing) "
"algorithms to be used."
msgstr ""
"``ExternalObject`` 접근 방식에 대해 주목해야 할 중요한 점은 초기화 데이터가 모델리카 소스 코드 완전히 외부에 있을 수 있다는 것입니다. "
"단순화를 위해 이 섹션에 표시된 예제 코드는 데이터 배열을 사용하여 ``VectorTable`` 을 초기화했지만, **파일 이름** 을 초기화 코드에 쉽게 전달할 수 있습니다. "
"그 파일은 ``createVectorTable`` 함수에 의해 읽힐 수 있고 ``VectorTable`` 구조의 내용은 그 파일의 데이터를 사용하여 초기화될 수 있습니다. "
"대부분의 경우 이러한 접근 방식은 데이터 관리를 더 쉽게 할 뿐만 아니라 C를 활용하면 더 복잡한(신규 또는 기존) 알고리즘을 사용할 수 있습니다."


#: ../../source/behavior/functions/interpolation.rst:350
msgid ""
"The :ref:`next section <sil-controller>` includes another example of how "
"external C code can be called from Modelica."
msgstr ""
":ref:`다음 섹션 <sil-controller>` 에는 모델리카에서 외부 C 코드를 호출할 수 있는 방법에 대한 또 다른 예가 포함되어 있습니다."

#~ msgid "ExternalObject"
#~ msgstr ""

