# 
msgid ""
msgstr ""
"Project-Id-Version: Modelica by Example 0.2.1\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2014-04-14 10:12-0400\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../../source/behavior/arrays/construction.rst:4
msgid "Array Construction"
msgstr ""

#: ../../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 ""

#: ../../source/behavior/arrays/construction.rst:12
msgid "Literals"
msgstr ""

#: ../../source/behavior/arrays/construction.rst:15
#: ../../source/behavior/arrays/construction.rst:0
msgid "Vectors"
msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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: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 ""

#: ../../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 ""

#: ../../source/behavior/arrays/construction.rst:98
msgid "Matrix Construction"
msgstr ""

#: ../../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 ""

#: ../../source/behavior/arrays/construction.rst:109
msgid ""
"In this case, the parameter ``B`` is equivalent to the following in "
"mathematical notation:"
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 ""

#: ../../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 ""

#: ../../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: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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../source/behavior/arrays/construction.rst:251
msgid "Array Comprehensions"
msgstr ""

#: ../../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."
"  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 ""

#: ../../source/behavior/arrays/construction.rst:263
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 ""
"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 ""

#: ../../source/behavior/arrays/construction.rst:283
msgid ""
"This code builds an array with 1800 elements with only a few lines of "
"Modelica code."
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 ""

#~ msgid ""
#~ "Note, care should be taken when vectors of reals in this way since issues "
#~ "with floating point representations may result in the vector no including "
#~ "the final value.  The following alternatives are also available (and "
#~ "probably more robust):"
#~ msgstr ""
