#*************************************************************
#*
#* Licensed to the Apache Software Foundation (ASF) under one
#* or more contributor license agreements.  See the NOTICE file
#* distributed with this work for additional information
#* regarding copyright ownership.  The ASF licenses this file
#* to you under the Apache License, Version 2.0 (the
#* "License"); you may not use this file except in compliance
#* with the License.  You may obtain a copy of the License at
#*
#*   http://www.apache.org/licenses/LICENSE-2.0
#*
#* Unless required by applicable law or agreed to in writing,
#* software distributed under the License is distributed on an
#* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
#* KIND, either express or implied.  See the License for the
#* specific language governing permissions and limitations
#* under the License.
#*
#************************************************************
msgid ""
msgstr ""
"Project-Id-Version: AOO-4-xx\n"
"POT-Creation-Date: \n"
"PO-Revision-Date: \n"
"Last-Translator: genLang (build process)\n"
"Language-Team: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=iso-8859-1\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: genLang\n"


#: text/smath/00/00000004.xhp#tit
msgid  "To access this function..."
msgstr ""

#: text/smath/00/00000004.xhp#hd_id3152598.1
msgid  "\<variable id=\"wie\"\>To access this function...\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153415.9
msgid  "Choose \<emph\>Edit - Next Marker\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3146971.85
msgid  "F4 key"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149021.10
msgid  "Choose \<emph\>Edit - Previous Marker\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153966.86
msgid  "Shift+F4"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154020.11
msgid  "Choose \<emph\>Edit - Next Error\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3150205.87
msgid  "F3 key"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149499.12
msgid  "Choose \<emph\>Edit - Previous Error\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3148870.88
msgid  "Shift+F3"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149127.32
msgid  "On the Tools bar, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154653
msgid  "\<image id=\"img_id3154765\" src=\"res/commandimagelist/sc_zoom100percent.png\" width=\"0.1665inch\" height=\"0.1665inch\"\>\<alt id=\"alt_id3154765\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147298.16
msgid  "Zoom 100%"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147407.18
msgid  "Choose \<emph\>View - Zoom In\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3156398.33
msgid  "On the Tools bar, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3150743
msgid  "\<image id=\"img_id3163822\" src=\"res/commandimagelist/sc_helpzoomin.png\" width=\"0.1665inch\" height=\"0.1665inch\"\>\<alt id=\"alt_id3163822\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154504.20
msgid  "Zoom In"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147366.21
msgid  "Choose \<emph\>View - Zoom Out\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149878.34
msgid  "On the Tools bar, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3150934
msgid  "\<image id=\"img_id3148387\" src=\"res/commandimagelist/sc_zoomminus.png\" width=\"0.222inch\" height=\"0.222inch\"\>\<alt id=\"alt_id3148387\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154871.23
msgid  "Zoom Out"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153922.24
msgid  "Choose \<emph\>View - Show All\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147169.35
msgid  "On the Tools bar, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3151265
msgid  "\<image id=\"img_id3151272\" src=\"res/commandimagelist/sc_zoom.png\" width=\"0.1665inch\" height=\"0.1665inch\"\>\<alt id=\"alt_id3151272\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154646.26
msgid  "Show All"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3150257.27
msgid  "Choose \<emph\>View - Update\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153619.89
msgid  "F9 key"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149289.36
msgid  "On the Tools bar, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147260
msgid  "\<image id=\"img_id3151168\" src=\"res/commandimagelist/sc_refresh.png\" width=\"0.1665inch\" height=\"0.1665inch\"\>\<alt id=\"alt_id3151168\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3145417.29
msgid  "Update"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154262.83
msgid  "\<variable id=\"neuzeichnen\"\>Choose \<emph\>View - AutoUpdate Display\</emph\>\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154273.69
msgid  "\<variable id=\"astopa\"\>Choose \<emph\>View - Elements\</emph\>\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3152942.70
msgid  "Open the context menu in the Commands window - choose \<emph\>Unary/Binary Operators\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154106.71
msgid  "Choose \<emph\>View - Elements\</emph\> - in the Elements window, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153535
msgid  "\<image id=\"img_id3151310\" src=\"starmath/res/im21101.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151310\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153774.72
msgid  "Unary/Binary Operators"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3150360.73
msgid  "Open the context menu in the Commands window - choose \<emph\>Relations\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154473.74
msgid  "Choose \<emph\>View - Elements\</emph\> - in the Elements window, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147531
msgid  "\<image id=\"img_id3151103\" src=\"starmath/res/bi21309.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151103\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3150833.75
msgid  "Relations"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149687.37
msgid  "Open the context menu in the Commands window - choose \<emph\>Operators\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149342.76
msgid  "Choose \<emph\>View - Elements\</emph\> - in the Elements window, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3146921
msgid  "\<image id=\"img_id3146927\" src=\"starmath/res/im21105.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3146927\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3148990.39
msgid  "Operators"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149297.40
msgid  "Open the context menu in the Commands window - choose \<emph\>Functions\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3143275.77
msgid  "Choose \<emph\>View - Elements\</emph\> - in the Elements window, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149103
msgid  "\<image id=\"img_id3154825\" src=\"starmath/res/im21104.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3154825\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149796.42
msgid  "Functions"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147092.43
msgid  "Open the context menu in the Commands window - choose \<emph\>Brackets\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147220.78
msgid  "Choose \<emph\>View - Elements\</emph\> - in the Elements window, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147584
msgid  "\<image id=\"img_id3148733\" src=\"starmath/res/im21107.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3148733\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147330.45
msgid  "Brackets"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153510.46
msgid  "Open the context menu in the Commands window - choose \<emph\>Attributes\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147126.79
msgid  "Choose \<emph\>View - Elements\</emph\> - in the Elements window, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154376
msgid  "\<image id=\"img_id3154390\" src=\"starmath/res/at21706.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154390\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153361.48
msgid  "Attributes"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154114.49
msgid  "Open the context menu in the Commands window - choose \<emph\>Formats\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3150581.80
msgid  "Choose \<emph\>View - Elements\</emph\> - in the Elements window, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3151029
msgid  "\<image id=\"img_id3151036\" src=\"starmath/res/im21108.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151036\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3155119.51
msgid  "Formats"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149008.52
msgid  "Open the context menu in the Commands window - choose \<emph\>Set Operations\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147313.81
msgid  "Choose \<emph\>View - Elements\</emph\> - in the Elements window, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3151377
msgid  "\<image id=\"img_id3151384\" src=\"starmath/res/op21401.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151384\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3150686.54
msgid  "Set Operations"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3150109.55
msgid  "\<variable id=\"fmtsfa\"\>Choose \<emph\>Format - Fonts\</emph\>\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3155860.56
msgid  "\<variable id=\"fmtssa\"\>Choose \<emph\>Format - Fonts - Modify\</emph\>\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147419.57
msgid  "\<variable id=\"fmtsgr\"\>Choose \<emph\>Format - Font Size\</emph\>\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147482.58
msgid  "\<variable id=\"fmtabs\"\>Choose \<emph\>Format - Spacing\</emph\>\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3147628.59
msgid  "\<variable id=\"fmtarg\"\>Choose \<emph\>Format - Alignment\</emph\>\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149553.93
msgid  "\<variable id=\"textmodus\"\>Choose \<emph\>Format - Text Mode\</emph\>\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3145131.60
msgid  "Choose \<emph\>Tools - Catalog\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3145268.82
msgid  "On the Tools bar, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153258
msgid  "\<image id=\"img_id3153264\" src=\"res/commandimagelist/sc_autosum.png\" width=\"0.222inch\" height=\"0.222inch\"\>\<alt id=\"alt_id3153264\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3148448.62
msgid  "Catalog"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3145318.63
msgid  "\<variable id=\"etssba\"\>Choose \<emph\>Tools - Catalog - Edit\</emph\>\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153802.64
msgid  "\<variable id=\"etsfim\"\>Choose \<emph\>Tools - Import Formula\</emph\>\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154594.65
msgid  "\<variable id=\"etsaps\"\>Choose \<emph\>Tools - Customize\</emph\>\</variable\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153291.90
msgid  "Open the context menu in the Commands window - choose \<emph\>Others\</emph\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3153968.91
msgid  "Choose \<emph\>View - Elements\</emph\> - in the Elements window, click"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3154715
msgid  "\<image id=\"img_id3154722\" src=\"starmath/res/im21117.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154722\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3150459.92
msgid  "Others"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3145626
msgid  "\<image id=\"img_id3145632\" src=\"res/commandimagelist/sc_formelcursor.png\" width=\"0.222inch\" height=\"0.222inch\"\>\<alt id=\"alt_id3145632\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/00/00000004.xhp#par_id3149768.95
msgid  "Formula Cursor"
msgstr ""

#: text/smath/01/02080000.xhp#tit
msgid  "Next Marker"
msgstr ""

#: text/smath/01/02080000.xhp#bm_id3154702
msgid  "\<bookmark_value\>markers; next\</bookmark_value\>\<bookmark_value\>placeholders; position of next\</bookmark_value\>\<bookmark_value\>markers; definition\</bookmark_value\>"
msgstr ""

#: text/smath/01/02080000.xhp#hd_id3154702.1
msgid  "\<link href=\"text/smath/01/02080000.xhp\" name=\"Next Marker\"\>Next Marker\</link\>"
msgstr ""

#: text/smath/01/02080000.xhp#par_id3150208.2
msgid  "\<ahelp hid=\"SID_NEXTMARK\"\>Moves the cursor to the next marker (to the right).\</ahelp\>"
msgstr ""

#: text/smath/01/02080000.xhp#par_id3149051.3
msgid  "\"Markers\" are placeholders. They take the form of <?> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/02090000.xhp#tit
msgid  "Previous Marker"
msgstr ""

#: text/smath/01/02090000.xhp#bm_id3153770
msgid  "\<bookmark_value\>markers; previous\</bookmark_value\>\<bookmark_value\>placeholders; previous marker\</bookmark_value\>"
msgstr ""

#: text/smath/01/02090000.xhp#hd_id3153770.1
msgid  "\<link href=\"text/smath/01/02090000.xhp\" name=\"Previous Marker\"\>Previous Marker\</link\>"
msgstr ""

#: text/smath/01/02090000.xhp#par_id3145252.2
msgid  "\<ahelp hid=\"SID_PREVMARK\" visibility=\"visible\"\>Moves the cursor to the previous marker (to the left).\</ahelp\>"
msgstr ""

#: text/smath/01/02090000.xhp#par_id3148488.3
msgid  "\"Markers\" are placeholders. They take the form of <?> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/02100000.xhp#tit
msgid  "Next Error"
msgstr ""

#: text/smath/01/02100000.xhp#bm_id3150299
msgid  "\<bookmark_value\>error search; next error\</bookmark_value\>\<bookmark_value\>finding ;errors in %PRODUCTNAME Math\</bookmark_value\>"
msgstr ""

#: text/smath/01/02100000.xhp#hd_id3150299.1
msgid  "\<link href=\"text/smath/01/02100000.xhp\" name=\"Next Error\"\>Next Error\</link\>"
msgstr ""

#: text/smath/01/02100000.xhp#par_id3145387.2
msgid  "\<ahelp hid=\"SID_NEXTERR\"\>Moves the cursor to the next error (moving right).\</ahelp\>"
msgstr ""

#: text/smath/01/02110000.xhp#tit
msgid  "Previous Error"
msgstr ""

#: text/smath/01/02110000.xhp#bm_id3147434
msgid  "\<bookmark_value\>error search; previous error\</bookmark_value\>"
msgstr ""

#: text/smath/01/02110000.xhp#hd_id3147434.1
msgid  "\<link href=\"text/smath/01/02110000.xhp\" name=\"Previous Error\"\>Previous Error\</link\>"
msgstr ""

#: text/smath/01/02110000.xhp#par_id3145799.2
msgid  "\<ahelp hid=\"SID_PREVERR\" visibility=\"visible\"\>Moves the cursor to the previous error (moving left).\</ahelp\>"
msgstr ""

#: text/smath/01/03040000.xhp#tit
msgid  "Zoom In"
msgstr ""

#: text/smath/01/03040000.xhp#bm_id3153770
msgid  "\<bookmark_value\>zooming in on formula display\</bookmark_value\>\<bookmark_value\>formulas; increasing size of display\</bookmark_value\>"
msgstr ""

#: text/smath/01/03040000.xhp#hd_id3153770.1
msgid  "\<link href=\"text/smath/01/03040000.xhp\" name=\"Zoom In\"\>Zoom In\</link\>"
msgstr ""

#: text/smath/01/03040000.xhp#par_id3154490.2
msgid  "\<ahelp hid=\".\"\>Increases the display scale of the formula by 25%.\</ahelp\> The current zoom factor is displayed on the status bar. A selection of available zoom options is accessible through the \<link href=\"text/shared/00/00000001.xhp#kontextmenue\" name=\"context menu\"\>context menu\</link\>. The context menu in the work area also contains zoom commands."
msgstr ""

#: text/smath/01/03050000.xhp#tit
msgid  "Zoom Out"
msgstr ""

#: text/smath/01/03050000.xhp#bm_id3147338
msgid  "\<bookmark_value\>views; zooming out $[officename] Math\</bookmark_value\>\<bookmark_value\>formula display sizes\</bookmark_value\>\<bookmark_value\>formulas; zooming out\</bookmark_value\>\<bookmark_value\>zooming out on formula display\</bookmark_value\>"
msgstr ""

#: text/smath/01/03050000.xhp#hd_id3147338.1
msgid  "\<link href=\"text/smath/01/03050000.xhp\" name=\"Zoom Out\"\>Zoom Out\</link\>"
msgstr ""

#: text/smath/01/03050000.xhp#par_id3150249.2
msgid  "\<ahelp hid=\".\"\>Decreases the display scale of formulas by 25%.\</ahelp\> The current zoom factor is displayed on the status bar. A selection of available zoom options is accessible through the \<link href=\"text/shared/00/00000001.xhp#kontextmenue\" name=\"context menu\"\>context menu\</link\>. The context menu in the work area also contains zoom commands."
msgstr ""

#: text/smath/01/03060000.xhp#tit
msgid  "Display All"
msgstr ""

#: text/smath/01/03060000.xhp#bm_id3147340
msgid  "\<bookmark_value\>views; maximum size\</bookmark_value\>\<bookmark_value\>maximum formula size\</bookmark_value\>\<bookmark_value\>formulas; maximum size\</bookmark_value\>"
msgstr ""

#: text/smath/01/03060000.xhp#hd_id3147340.1
msgid  "\<link href=\"text/smath/01/03060000.xhp\" name=\"Show All\"\>Show All / Display All\</link\>"
msgstr ""

#: text/smath/01/03060000.xhp#par_id3148571.2
msgid  "\<ahelp hid=\".\"\>Displays the entire formula in the maximum size possible so that all elements are included. The formula is reduced or enlarged so that all formula elements can be displayed in the work area.\</ahelp\> The current zoom factor is displayed on the status bar. A selection of available zoom options is accessible through the \<link href=\"text/shared/00/00000001.xhp#kontextmenue\" name=\"context menu\"\>context menu\</link\>. The context menu in the work area also contains zoom commands. The name of the icon is \"Show All\", the name of the context menu command is \"Display All\". The zoom commands and icons are only available in Math documents, not for embedded Math objects."
msgstr ""

#: text/smath/01/03070000.xhp#tit
msgid  "Update"
msgstr ""

#: text/smath/01/03070000.xhp#bm_id3153768
msgid  "\<bookmark_value\>updating formula view\</bookmark_value\>\<bookmark_value\>formula view; updating\</bookmark_value\>"
msgstr ""

#: text/smath/01/03070000.xhp#hd_id3153768.1
msgid  "\<link href=\"text/smath/01/03070000.xhp\" name=\"Update\"\>Update\</link\>"
msgstr ""

#: text/smath/01/03070000.xhp#par_id3153729.2
msgid  "\<ahelp hid=\"SID_DRAW\"\>This command updates the formula in the document window.\</ahelp\>"
msgstr ""

#: text/smath/01/03070000.xhp#par_id3145253.3
msgid  "Changes in the \<emph\>Commands\</emph\> window are automatically updated if \<emph\>AutoUpdate Display\</emph\> is activated."
msgstr ""

#: text/smath/01/03080000.xhp#tit
msgid  "AutoUpdate Display"
msgstr ""

#: text/smath/01/03080000.xhp#bm_id3154702
msgid  "\<bookmark_value\>changes; accepting automatically\</bookmark_value\>"
msgstr ""

#: text/smath/01/03080000.xhp#hd_id3154702.1
msgid  "\<link href=\"text/smath/01/03080000.xhp\" name=\"AutoUpdate Display\"\>AutoUpdate Display\</link\>"
msgstr ""

#: text/smath/01/03080000.xhp#par_id3154656.2
msgid  "\<ahelp hid=\".\"\>Automatically updates a modified formula. If you do not select this option, the formula will only be updated after you choose \<emph\>View - Update\</emph\> or press F9.\</ahelp\>"
msgstr ""

#: text/smath/01/03090000.xhp#tit
msgid  "Elements"
msgstr ""

#: text/smath/01/03090000.xhp#bm_id3155963
msgid  "\<bookmark_value\>selection options in formulas\</bookmark_value\>         \<bookmark_value\>formulas; selections\</bookmark_value\>         \<bookmark_value\>elements;in Math\</bookmark_value\>"
msgstr ""

#: text/smath/01/03090000.xhp#hd_id3155963.1
msgid  "\<variable id=\"func_win\"\>\<link href=\"text/smath/01/03090000.xhp\" name=\"Elements\"\>Elements\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03090000.xhp#par_id3149500.2
msgid  "\<ahelp hid=\"SID_TOOLBOX\"\>This is a list of operators, functions, symbols and format options that can be inserted into the formula.\</ahelp\>"
msgstr ""

#: text/smath/01/03090000.xhp#par_id3148699.5
msgid  "Some \<link href=\"text/smath/01/03090900.xhp\" name=\"examples\"\>examples\</link\> show you the range of operations."
msgstr ""

#: text/smath/01/03090000.xhp#par_id3151244.6
msgid  "The selection window is divided into two parts. Clicking a symbol at the top of the window displays its subordinate symbols in the lower half of the window."
msgstr ""

#: text/smath/01/03090000.xhp#par_id3153250.7
msgid  "You can access the same functions in submenus through the context menu of the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#tit
msgid  "Unary/Binary Operators"
msgstr ""

#: text/smath/01/03090100.xhp#bm_id3150342
msgid  "\<bookmark_value\>unary operators\</bookmark_value\>\<bookmark_value\>binary operators\</bookmark_value\>\<bookmark_value\>operators; unary and binary\</bookmark_value\>\<bookmark_value\>plus signs\</bookmark_value\>\<bookmark_value\>plus/minus signs\</bookmark_value\>\<bookmark_value\>minus/plus signs\</bookmark_value\>\<bookmark_value\>multiplication signs\</bookmark_value\>\<bookmark_value\>NOT operator\</bookmark_value\>\<bookmark_value\>AND operator\</bookmark_value\>\<bookmark_value\>logical operators\</bookmark_value\>\<bookmark_value\>Boolean operators\</bookmark_value\>\<bookmark_value\>OR operator\</bookmark_value\>\<bookmark_value\>concatenating math symbols\</bookmark_value\>\<bookmark_value\>addition signs\</bookmark_value\>\<bookmark_value\>subtraction signs\</bookmark_value\>\<bookmark_value\>minus signs\</bookmark_value\>\<bookmark_value\>slash division sign\</bookmark_value\>\<bookmark_value\>backslash division sign\</bookmark_value\>\<bookmark_value\>indexes; adding to formulas\</bookmark_value\>\<bookmark_value\>powers\</bookmark_value\>\<bookmark_value\>division signs\</bookmark_value\>\<bookmark_value\>user-defined operators;unary and binary\</bookmark_value\>"
msgstr ""

#: text/smath/01/03090100.xhp#hd_id3150342.1
msgid  "\<link href=\"text/smath/01/03090100.xhp\" name=\"Unary/Binary Operators\"\>Unary/Binary Operators\</link\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3151241.2
msgid  "\<ahelp hid=\"HID_SMA_UNBINOPS_CAT\"\>You can choose various unary and binary operators to build your $[officename] Math formula. Unary refers to operators that affect one placeholder. Binary refers to operators that connect two placeholders. The lower area of the Elements window displays the individual operators.\</ahelp\> The \<link href=\"text/shared/00/00000001.xhp#kontextmenue\" name=\"context menu\"\>context menu\</link\> of the \<emph\>Commands\</emph\> window also contains a list of these operators, as well as additional operators. If you need an operator that is not contained in the Elements window, use the context menu or type it directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3146963.3
msgid  "The following is a complete list of the unary and binary operators. The symbol next to the operator indicates that it can be accessed through the Elements window (choose \<emph\>View - Elements\</emph\>) or through the context menu of the Commands window."
msgstr ""

#: text/smath/01/03090100.xhp#hd_id3147405.4
msgid  "Unary and Binary Operators"
msgstr ""

#: text/smath/01/03090100.xhp#par_idN10085
msgid  "\<image id=\"img_id3156399\" src=\"starmath/res/un21201.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3156399\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3154555.5
msgid  "Plus"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3153003.6
msgid  "\<ahelp hid=\"HID_SMA_PLUSX\"\>Inserts a \<emph\>plus\</emph\> with one placeholder.\</ahelp\> You can also type \<emph\>+ <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN100C1
msgid  "\<image id=\"img_id3148776\" src=\"starmath/res/un21202.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3148776\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3155991.7
msgid  "Minus"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3153717.44
msgid  "\<ahelp hid=\"HID_SMA_MINUSX\"\>Inserts a \<emph\>minus\</emph\> with one placeholder.\</ahelp\> You can also type \<emph\>-<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN100FD
msgid  "\<image id=\"img_id3150757\" src=\"starmath/res/un21203.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150757\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3153150.46
msgid  "Plus/Minus"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3150260.45
msgid  "\<ahelp hid=\"HID_SMA_PLUSMINUSX\"\>Inserts a \<emph\>plus/minus\</emph\> with one placeholder.\</ahelp\> You can also type \<emph\>+-<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN10139
msgid  "\<image id=\"img_id3145410\" src=\"starmath/res/un21204.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3145410\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3153582.48
msgid  "Minus/Plus"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3154281.47
msgid  "\<ahelp hid=\"HID_SMA_MINUSPLUSX\"\>Inserts a \<emph\>minus/plus\</emph\> with one placeholder.\</ahelp\> You can also type \<emph\>-+<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN10175
msgid  "\<image id=\"img_id3151098\" src=\"starmath/res/un21205.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151098\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3153669.49
msgid  "Addition (plus)"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3150351.8
msgid  "\<ahelp hid=\"HID_SMA_XPLUSY\"\>Inserts a \<emph\>plus\</emph\> with two placeholders.\</ahelp\> You can also type \<emph\><?>+<?>\</emph\> in the Commands window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN101B0
msgid  "\<image id=\"img_id3155898\" src=\"starmath/res/un21206.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155898\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3149343.29
msgid  "Multiplication (dot)"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3154196.28
msgid  "\<ahelp hid=\"HID_SMA_XCDOTY\"\>Inserts a dot operator with two placeholders.\</ahelp\> You can also type \<emph\><?>cdot<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN101E9
msgid  "\<image id=\"img_id3149308\" src=\"starmath/res/un21207.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149308\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3151257.19
msgid  "Multiplication (x)"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3149821.20
msgid  "\<ahelp hid=\"HID_SMA_XTIMESY\"\>Inserts an 'x' \<emph\>multiplication\</emph\> with two placeholders.\</ahelp\> You can also type \<emph\><?>times<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN10226
msgid  "\<image id=\"img_id3148982\" src=\"starmath/res/un21208.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3148982\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3159486.11
msgid  "Multiplication (*)"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3149040.12
msgid  "\<ahelp hid=\"HID_SMA_XSYMTIMESY\"\>Inserts an asterisk multiplication sign with two placeholders. \</ahelp\> You can also type \<emph\><?>*<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN1025F
msgid  "\<image id=\"img_id3155140\" src=\"starmath/res/un21209.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155140\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3147124.9
msgid  "Subtraction"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3147136.10
msgid  "\<ahelp hid=\"HID_SMA_XMINUSY\"\>Inserts a subtraction sign with two placeholders.\</ahelp\> You can also type \<emph\><?>-<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN10298
msgid  "\<image id=\"img_id3149168\" src=\"starmath/res/un21210.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149168\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3154926.17
msgid  "Division (Fraction)"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3155125.18
msgid  "\<ahelp hid=\"HID_SMA_XOVERY\"\>Inserts a fraction with two placeholders.\</ahelp\> You can also type \<emph\><?>over<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN102D1
msgid  "\<image id=\"img_id3148765\" src=\"starmath/res/un21211.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3148765\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3151377.13
msgid  "Division"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3149536.14
msgid  "\<ahelp hid=\"HID_SMA_XDIVY\"\>Inserts a division sign with two placeholders.\</ahelp\> You can also type \<emph\><?>div<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN1030A
msgid  "\<image id=\"img_id3147418\" src=\"starmath/res/un21212.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3147418\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3147487.15
msgid  "Division (Slash)"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3147500.16
msgid  "\<ahelp hid=\"HID_SMA_XSYMDIVIDEY\"\>Inserts a slash '/' with two placeholders. \</ahelp\> You can also type \<emph\><?>/<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN10343
msgid  "\<image id=\"img_id3149566\" src=\"starmath/res/un21213.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3149566\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3153493.30
msgid  "Boolean NOT"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3153505.26
msgid  "\<ahelp hid=\"HID_SMA_NEGX\"\>Inserts a \<emph\>Boolean NOT\</emph\> with one placeholder.\</ahelp\> You can also type \<emph\>neg<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN10383
msgid  "\<image id=\"img_id3147116\" src=\"starmath/res/un21214.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3147116\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3149847.21
msgid  "Boolean AND"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3147599.22
msgid  "\<ahelp hid=\"HID_SMA_XANDY\"\>Inserts a \<emph\>Boolean AND\</emph\> with two placeholders.\</ahelp\> You can also type \<emph\><?>and<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN103C3
msgid  "\<image id=\"img_id3148440\" src=\"starmath/res/un21215.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3148440\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3151086.23
msgid  "Boolean OR"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3154076.38
msgid  "\<ahelp hid=\"HID_SMA_XORY\"\>Inserts a \<emph\>Boolean OR\</emph\> with two placeholders.\</ahelp\> You can also type \<emph\><?>or<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_idN10403
msgid  "\<image id=\"img_id3150173\" src=\"starmath/res/un21221.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150173\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3151129.40
msgid  "Concatenate"
msgstr ""

#: text/smath/01/03090100.xhp#par_id3156102.39
msgid  "\<ahelp hid=\"HID_SMA_XCIRCY\"\>Inserts a \<emph\>concatenation sign\</emph\> with two placeholders. \</ahelp\> You can also type \<emph\>circ\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3150464.27
msgid  "You can also insert user-defined unary operators by typing \<emph\>uoper\</emph\> in the \<emph\>Commands\</emph\> window, followed by the syntax for the character. This function is useful for incorporating special characters into a formula. For example, the command \<emph\>uoper %theta x\</emph\> produces a small Greek letter theta (a component of the \<emph\>$[officename] Math\</emph\> character set). You can also insert characters not in the $[officename] character set by choosing \<emph\>Tools - Catalog - Edit\</emph\>."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3154725.31
msgid  " You can also insert user-defined binary commands by typing \<emph\>boper\</emph\> into the \<emph\>Commands\</emph\> window. For example, the command \<emph\>y boper %theta x\</emph\> produces the small Greek letter theta preceded by a \<emph\>y\</emph\> and followed by an \<emph\>x\</emph\>. You can also insert characters not in the $[officename] character set by choosing \<emph\>Tools - Catalog - Edit\</emph\>."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3150906.32
msgid  "By typing \<emph\><?>oplus<?>\</emph\> in the \<emph\>Commands\</emph\> window, you insert a \<emph\>circled plus operator\</emph\> in your document."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3151197.33
msgid  "Type \<emph\><?>ominus<?>\</emph\> in the \<emph\>Commands\</emph\> window to insert a \<emph\>circled minus operator\</emph\>."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3155082.34
msgid  "Type \<emph\><?>odot<?>\</emph\> in the \<emph\>Commands\</emph\> window to insert a \<emph\>circled dot operator\</emph\> in the formula."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3154331.35
msgid  "Type \<emph\><?>odivide<?>\</emph\> in the \<emph\>Commands\</emph\> window to insert a \<emph\>circled division operator\</emph\> in the formula."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3150089.42
msgid  "\<ahelp hid=\"HID_SMA_XWIDESLASHY\"\>Type \<emph\>a wideslash b\</emph\> in the \<emph\>Commands\</emph\> window to produce two characters with a slash (from lower left to upper right) between them.\</ahelp\> The characters are set such that everything to the left of the slash is up, and everything to the right is down. This command is also available in the context menu of the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3150024.43
msgid  "\<ahelp hid=\"HID_SMA_XWIDEBSLASHY\"\>Type \<emph\>a widebslash b\</emph\> in the \<emph\>Commands\</emph\> window to produce two characters with a slash (from upper left to lower right) between them.\</ahelp\> The characters are set such that everything to the left of the slash is down, and everything to the right is up. This command is also available in the context menu of the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3149376.36
msgid  "Type \<emph\>sub\</emph\> or \<emph\>sup\</emph\> in the Commands window to add indexes and powers to the characters in your formula; for example, a sub 2."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3155383.41
msgid  "If you want to use a colon ':' as division sign, choose \<emph\>Tools - Catalog\</emph\> or click the \<emph\>Catalog\</emph\> icon on the Tools bar. Click the \<emph\>Edit\</emph\> button in the dialog that appears, then select the \<emph\>Special\</emph\> symbol set. Enter a meaningful name next to \<emph\>Symbol\</emph\>, for example, \"divide\" and then click the colon in the set of symbols. Click \<emph\>Add\</emph\> and then \<emph\>OK\</emph\>. Click \<emph\>OK\</emph\> to close the \<emph\>Symbols\</emph\> dialog,too. Now you can use the new symbol, in this case the colon, by entering its name in the Commands window, for example, \<emph\>a %divide b = c\</emph\>."
msgstr ""

#: text/smath/01/03090100.xhp#par_id3147398.37
msgid  "When entering information manually in the Commands window, please note that a number of operators require spaces between the elements for the correct structure. This is especially true if you are using values instead of placeholders in your operators, for example, to construct a division 4 div 3 or a div b."
msgstr ""

#: text/smath/01/03090200.xhp#tit
msgid  "Relations"
msgstr ""

#: text/smath/01/03090200.xhp#bm_id3156316
msgid  "\<bookmark_value\>relations; in $[officename] Math\</bookmark_value\>\<bookmark_value\>$[officename] Math; relations\</bookmark_value\>\<bookmark_value\>equal sign\</bookmark_value\>\<bookmark_value\>inequation\</bookmark_value\>\<bookmark_value\>unequal sign\</bookmark_value\>\<bookmark_value\>identical to relation\</bookmark_value\>\<bookmark_value\>congruent relation\</bookmark_value\>\<bookmark_value\>right angled relations\</bookmark_value\>\<bookmark_value\>orthogonal relations\</bookmark_value\>\<bookmark_value\>divides relation\</bookmark_value\>\<bookmark_value\>does not divide relation\</bookmark_value\>\<bookmark_value\>less than relations\</bookmark_value\>\<bookmark_value\>approximately equal to relation\</bookmark_value\>\<bookmark_value\>parallel relation\</bookmark_value\>\<bookmark_value\>less than or equal to signs\</bookmark_value\>\<bookmark_value\>greater than or equal to signs\</bookmark_value\>\<bookmark_value\>proportional to relation\</bookmark_value\>\<bookmark_value\>similar to relations\</bookmark_value\>\<bookmark_value\>toward relation\</bookmark_value\>\<bookmark_value\>logic symbols\</bookmark_value\>\<bookmark_value\>double arrow symbols\</bookmark_value\>\<bookmark_value\>much greater than relation\</bookmark_value\>\<bookmark_value\>considerably greater than relation\</bookmark_value\>\<bookmark_value\>greater than relations\</bookmark_value\>\<bookmark_value\>much less than relation\</bookmark_value\>\<bookmark_value\>considerably less than relation\</bookmark_value\>\<bookmark_value\>defined as relation\</bookmark_value\>\<bookmark_value\>correspondence; picture by\</bookmark_value\>\<bookmark_value\>picture by correspondence\</bookmark_value\>\<bookmark_value\>image of relation\</bookmark_value\>\<bookmark_value\>correspondence; original by\</bookmark_value\>\<bookmark_value\>original by correspondence\</bookmark_value\>"
msgstr ""

#: text/smath/01/03090200.xhp#hd_id3156316.1
msgid  "\<link href=\"text/smath/01/03090200.xhp\" name=\"Relations\"\>Relations\</link\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3153152.2
msgid  "\<ahelp hid=\"HID_SMA_RELATIONS_CAT\"\>You can choose among various relations to structure your \<emph\>$[officename] Math\</emph\> formula. The relation functions are displayed in the lower part of the Elements window.\</ahelp\> The list is also in the \<link href=\"text/shared/00/00000001.xhp#kontextmenue\" name=\"context menu\"\>context menu\</link\> of the \<emph\>Commands\</emph\> window. All relations that are not contained in the Elements window or in the context menu can be typed manually in the Commands window."
msgstr ""

#: text/smath/01/03090200.xhp#par_id3147258.3
msgid  "The following is a complete list of the relations. The symbol next to the name of the relation indicates that it can be accessed through the Elements window (choose \<emph\>View - Elements\</emph\>) or through the context menu of the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#hd_id3148827.4
msgid  "Relations:"
msgstr ""

#: text/smath/01/03090200.xhp#par_idN10086
msgid  "\<image id=\"img_id3153573\" src=\"starmath/res/bi21301.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3153573\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3154104.5
msgid  "is equal"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3152947.6
msgid  "\<ahelp hid=\"HID_SMA_XEQY\"\>Inserts an equal sign (=) with two placeholders.\</ahelp\> You can also directly type \<emph\><?> = <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN100BF
msgid  "\<image id=\"img_id3147523\" src=\"starmath/res/bi21302.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3147523\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3152959.54
msgid  "does not equal"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3150976.53
msgid  "\<ahelp hid=\"HID_SMA_XNEQY\"\>The \<emph\>neq\</emph\> icon or command inserts an \<emph\>inequality\</emph\> with two placeholders.\</ahelp\> You can also type \<emph\><?> neq <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN10101
msgid  "\<image id=\"img_id3154196\" src=\"starmath/res/bi21303.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3154196\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3151332.56
msgid  "identical to"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3155181.55
msgid  "\<ahelp hid=\"HID_SMA_XEQUIVY\"\>Inserts a character for the \<emph\>identical to\</emph\> (congruent) relation with two placeholders.\</ahelp\> You can also type \<emph\><?> equiv <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN10140
msgid  "\<image id=\"img_id3154835\" src=\"starmath/res/bi21304.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3154835\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3147098.58
msgid  "orthogonal to"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3148976.57
msgid  "\<ahelp hid=\"HID_SMA_XORTHOY\"\>Inserts a character for an \<emph\>orthogonal\</emph\> (right angled) relation with two placeholders.\</ahelp\> You can also type \<emph\><?> ortho <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN10182
msgid  "\<image id=\"img_id3147321\" src=\"starmath/res/bi21322.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3147321\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3153523.80
msgid  "divides"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3147079.79
msgid  "\<ahelp hid=\"HID_SMA_XDIVIDESY\"\>Inserts the \<emph\>divides\</emph\> character.\</ahelp\> You can also type \<emph\><?> divides <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN101BF
msgid  "\<image id=\"img_id3151030\" src=\"starmath/res/bi21323.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3151030\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3149164.82
msgid  "does not divide"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3149177.81
msgid  "\<ahelp hid=\"HID_SMA_XNDIVIDESY\"\>This icon inserts the \<emph\>does not divide\</emph\> character.\</ahelp\> You can also type \<emph\><?>ndivides<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN101FC
msgid  "\<image id=\"img_id3155133\" src=\"starmath/res/bi21305.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3155133\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3148877.27
msgid  "less than"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3148889.28
msgid  "\<ahelp hid=\"HID_SMA_XLTY\"\>Inserts the \<emph\>less than\</emph\> relation.\</ahelp\> You can also type \<emph\><?>lt<?>\</emph\> or <?> < <?> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN1023B
msgid  "\<image id=\"img_id3147468\" src=\"starmath/res/bi21306.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3147468\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3147495.25
msgid  "greater than"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3146904.26
msgid  "\<ahelp hid=\"HID_SMA_XGTY\"\>Inserts the \<emph\>greater than \</emph\>relation.\</ahelp\> You can also type \<emph\><?> gt <?>\</emph\> or <?> > <?> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN10279
msgid  "\<image id=\"img_id3155982\" src=\"starmath/res/bi21307.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3155982\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3149218.60
msgid  "approximately equal to"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3149231.59
msgid  "\<ahelp hid=\"HID_SMA_XAPPROXY\"\>Inserts the \<emph\>approximately equal\</emph\> relation with two placeholders.\</ahelp\> You can also type \<emph\><?> approx <?> \</emph\>in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN102B5
msgid  "\<image id=\"img_id3155773\" src=\"starmath/res/bi21308.png\" width=\"0.566cm\" height=\"0.566cm\"\>\<alt id=\"alt_id3155773\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3147598.62
msgid  "parallel to"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3147449.61
msgid  "\<ahelp hid=\"HID_SMA_XPARALLELY\"\>Inserts a \<emph\>parallel \</emph\>relation with two placeholders.\</ahelp\> You can also type \<emph\><?>parallel<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN102F3
msgid  "\<image id=\"img_id3148442\" src=\"starmath/res/bi21309.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3148442\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3151089.64
msgid  "less than or equal to (slanted)"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3154078.63
msgid  "\<ahelp hid=\"HID_SMA_XLESLANTY\"\>Inserts a \<emph\>less than or equal to\</emph\> relation with two placeholders.\</ahelp\> You can also type \<emph\><?> leslant <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN10331
msgid  "\<image id=\"img_id3153299\" src=\"starmath/res/bi21310.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3153299\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3150171.66
msgid  "greater than or equal to (slanted)"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3156098.65
msgid  "\<ahelp hid=\"HID_SMA_XGESLANTY\"\>Inserts the \<emph\>greater than or equal to\</emph\> relation with two placeholders.\</ahelp\> You can also type \<emph\><?>geslant<?> \</emph\>in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN1036F
msgid  "\<image id=\"img_id3153976\" src=\"starmath/res/bi21311.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3153976\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3145336.68
msgid  "similar or equal to"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3155580.67
msgid  "\<ahelp hid=\"HID_SMA_XSIMEQY\"\>Inserts the \<emph\>similar or equal to\</emph\> relation with two placeholders.\</ahelp\> You can also type \<emph\><?>simeq<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN103AD
msgid  "\<image id=\"img_id3151195\" src=\"starmath/res/bi21312.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3151195\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3155076.70
msgid  "proportional to"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3155088.69
msgid  "\<ahelp hid=\"HID_SMA_XPROPY\"\>Inserts the \<emph\>proportional to\</emph\> relation with two placeholders.\</ahelp\> You can also type \<emph\><?> prop <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN103EB
msgid  "\<image id=\"img_id3150103\" src=\"starmath/res/bi21313.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3150103\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3150006.31
msgid  "less than or equal to"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3150033.32
msgid  "\<ahelp hid=\"HID_SMA_XLEY\"\>Inserts the \<emph\>less than or equal to\</emph\> relation with two placeholders.\</ahelp\> You can also type \<emph\><?> le <?>\</emph\> or \<emph\><?> <= <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN1042C
msgid  "\<image id=\"img_id3151228\" src=\"starmath/res/bi21314.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3151228\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3153131.29
msgid  "greater than or equal to"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3155379.30
msgid  "\<ahelp hid=\"HID_SMA_XGEY\"\>Inserts the \<emph\>greater than or equal to\</emph\> relation with two placeholders.\</ahelp\> You can also type \<emph\><?> ge <?>\</emph\> or \<emph\><?> >= <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN1046D
msgid  "\<image id=\"img_id3151003\" src=\"starmath/res/bi21315.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3151003\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3155935.72
msgid  "similar to"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3155947.71
msgid  "\<ahelp hid=\"HID_SMA_XSIMY\"\>This icon inserts the \<emph\>similar to\</emph\> relation with two placeholders.\</ahelp\> You can also type \<emph\><?>sim<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN104AB
msgid  "\<image id=\"img_id3149631\" src=\"starmath/res/bi21316.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3149631\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3150659.73
msgid  "toward"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3150670.42
msgid  "\<ahelp hid=\"HID_SMA_XTOWARDY\"\>Inserts a \<emph\>toward\</emph\> relation symbol with two placeholders.\</ahelp\> You can also type \<emph\><?> toward <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN104E7
msgid  "\<image id=\"img_id3149969\" src=\"starmath/res/bi21324.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3149969\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3147279.84
msgid  "double arrow pointing left"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3149599.83
msgid  "\<ahelp hid=\"HID_SMA_DLARROW\"\>Inserts the logical relation \<emph\>arrow with double bar pointing left\</emph\>.\</ahelp\> You can also type \<emph\>dlarrow\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN10525
msgid  "\<image id=\"img_id3149516\" src=\"starmath/res/bi21325.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3149516\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3148707.86
msgid  "double arrow pointing left and right"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3148721.85
msgid  "\<ahelp hid=\"HID_SMA_DLRARROW\"\>Inserts the logical relation \<emph\>arrow with double bar pointing left and right\</emph\> with two operators.\</ahelp\> You can also type \<emph\>dlrarrow\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_idN10563
msgid  "\<image id=\"img_id3148697\" src=\"starmath/res/bi21326.png\" width=\"0.847cm\" height=\"0.847cm\"\>\<alt id=\"alt_id3148697\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3150853.88
msgid  "double arrow pointing right"
msgstr ""

#: text/smath/01/03090200.xhp#par_id3150866.87
msgid  "\<ahelp hid=\"HID_SMA_DRARROW\"\>Inserts the logical operator \<emph\>arrow with double bar pointing right\</emph\> with two placeholders.\</ahelp\> You can also type \<emph\>drarrow\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_id3153545.74
msgid  "To create the \<emph\>much greater than\</emph\> relation with two placeholders, type \<emph\><?> gg <?> \</emph\>or \<emph\>>>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_id3156000.75
msgid  "Type \<emph\>ll\</emph\> or \<emph\><<\</emph\> in the \<emph\>Commands\</emph\> window to insert the \<emph\>much less than\</emph\> relation into the formula."
msgstr ""

#: text/smath/01/03090200.xhp#par_id3153749.76
msgid  "The \<emph\>is defined as\</emph\> relation with two placeholders is inserted by typing \<emph\><?>def<?>\</emph\>."
msgstr ""

#: text/smath/01/03090200.xhp#par_id3154068.77
msgid  "Insert the \<emph\>picture by\</emph\> correspondence character with two placeholders by typing \<emph\><?> transl <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090200.xhp#par_id3149592.78
msgid  "The \<emph\><?>transr<?>\</emph\> command inserts the \<emph\>original by\</emph\> correspondence character with two placeholders."
msgstr ""

#: text/smath/01/03090200.xhp#par_id3154735.52
msgid  "When entering information manually in the \<emph\>Commands\</emph\> window, note that a number of operators require spaces for the correct structure. This is especially true if you are working with values instead of placeholders. For example, for the \"is considerably greater\" relation, type either \<emph\>10 gg 1\</emph\> or \<emph\>a gg b\</emph\>."
msgstr ""

#: text/smath/01/03090300.xhp#tit
msgid  "Operators"
msgstr ""

#: text/smath/01/03090300.xhp#bm_id3153150
msgid  "\<bookmark_value\>operators; general\</bookmark_value\>\<bookmark_value\>upper limits\</bookmark_value\>\<bookmark_value\>limits; in %PRODUCTNAME Math\</bookmark_value\>\<bookmark_value\>product\</bookmark_value\>\<bookmark_value\>coproduct\</bookmark_value\>\<bookmark_value\>lower limits\</bookmark_value\>\<bookmark_value\>curve integrals\</bookmark_value\>\<bookmark_value\>user-defined operators; general\</bookmark_value\>\<bookmark_value\>integrals; signs\</bookmark_value\>\<bookmark_value\>summation\</bookmark_value\>"
msgstr ""

#: text/smath/01/03090300.xhp#hd_id3153150.1
msgid  "\<link href=\"text/smath/01/03090300.xhp\" name=\"Operators\"\>Operators\</link\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3149755.35
msgid  "\<ahelp hid=\"HID_SMA_OPERATORS_CAT\"\>You can choose among various operators to structure your \<emph\>$[officename] Math\</emph\> formula. All available operators appear in the lower part of the Elements window.\</ahelp\> They are also listed in the \<link href=\"text/shared/00/00000001.xhp#kontextmenue\" name=\"context menu\"\>context menu\</link\> of the \<emph\>Commands\</emph\> window. All operators not contained in the Elements window or in the context menu must be typed manually in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_id3153576.36
msgid  "The following is a list of the available operators. An icon next to the operator name indicates that it can be accessed through the Elements window (choose \<emph\>View - Elements\</emph\>) or through the context menu of the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#hd_id3147516.37
msgid  "Operator Functions"
msgstr ""

#: text/smath/01/03090300.xhp#par_idN10088
msgid  "\<image id=\"img_id3152944\" src=\"starmath/res/fo21601.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3152944\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3153527.11
msgid  "Limit"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3153540.12
msgid  "\<ahelp hid=\"HID_SMA_LIMX\"\>Inserts the \<emph\>limit sign\</emph\> with one placeholder.\</ahelp\> You can also enter \<emph\>lim <?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN100C4
msgid  "\<image id=\"img_id3150970\" src=\"starmath/res/fo21602.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150970\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3154475.38
msgid  "Summation"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3147523.6
msgid  "\<ahelp hid=\"HID_SMA_SUMX\"\>Inserts a \<emph\>summation sign\</emph\> with one placeholder.\</ahelp\> You can also enter \<emph\>sum <?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN10102
msgid  "\<image id=\"img_id3146932\" src=\"starmath/res/fo21603.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3146932\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3155184.40
msgid  "Product"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3151332.39
msgid  "\<ahelp hid=\"HID_SMA_PRODX\"\>Inserts a \<emph\>product sign\</emph\> with one placeholder.\</ahelp\> You can also type \<emph\>prod <?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN1013E
msgid  "\<image id=\"img_id3149814\" src=\"starmath/res/fo21604.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3149814\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3148982.9
msgid  "Coproduct"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3147098.10
msgid  "\<ahelp hid=\"HID_SMA_COPRODX\"\>Inserts a \<emph\>coproduct symbol\</emph\> with one placeholder.\</ahelp\> You can also enter \<emph\>coprod <?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN1017A
msgid  "\<image id=\"img_id3152766\" src=\"starmath/res/fo21613.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3152766\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3155146.29
msgid  "Upper and Lower Limit"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3153518.30
msgid  "\<ahelp hid=\"HID_SMA_FROMXTOY\"\>Inserts a range statement \<emph\>upper and lower limit\</emph\> for integral and summation with one placeholder.\</ahelp\> You can also type \<emph\>from{<?>} to{<?>} <?>\</emph\> directly in the \<emph\>Commands\</emph\> window. Limit statements must be combined with the appropriate operators. The limits will be centered above/below the summation character."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN101B8
msgid  "\<image id=\"img_id3151023\" src=\"starmath/res/fo21605.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3151023\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3149175.15
msgid  "Integral"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3156272.16
msgid  "\<ahelp hid=\"HID_SMA_INTX\"\>Inserts an \<emph\>integral\</emph\> sign with one placeholder.\</ahelp\> You can also type \<emph\>int <?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN101F4
msgid  "\<image id=\"img_id3145772\" src=\"starmath/res/fo21606.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3145772\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3151379.17
msgid  "Double Integral"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3148879.18
msgid  "\<ahelp hid=\"HID_SMA_IINTX\"\>Inserts a \<emph\>double integral\</emph\> symbol with one placeholder.\</ahelp\> You can also type \<emph\>iint <?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN10230
msgid  "\<image id=\"img_id3147409\" src=\"starmath/res/fo21607.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3147409\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3147618.19
msgid  "Triple Integral"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3147489.20
msgid  "\<ahelp hid=\"HID_SMA_IIINTX\"\>Inserts \<emph\>a triple integral\</emph\> sign with one placeholder.\</ahelp\> You can also type \<emph\>iiint <?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN1026C
msgid  "\<image id=\"img_id3149562\" src=\"starmath/res/fo21614.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149562\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3153508.31
msgid  "Lower Limit"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3150556.32
msgid  "\<ahelp hid=\"HID_SMA_FROMX\"\>Inserts a \<emph\>lower limit\</emph\> range statement for integral and sum with placeholders.\</ahelp\> You can also type \<emph\>from {<?>}<?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN102AA
msgid  "\<image id=\"img_id3147109\" src=\"starmath/res/fo21609.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3147109\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3149839.21
msgid  "Curve Integral"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3147592.22
msgid  "\<ahelp hid=\"HID_SMA_LINTX\"\>Inserts a \<emph\>curve integral\</emph\> symbol with one placeholder.\</ahelp\> You can also type \<emph\>lint <?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN102E6
msgid  "\<image id=\"img_id3147055\" src=\"starmath/res/fo21610.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3147055\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3151086.23
msgid  "Double Curve Integral"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3154770.24
msgid  "\<ahelp hid=\"HID_SMA_LLINTX\"\>Inserts a \<emph\>double curve integral\</emph\> symbol with one placeholder.\</ahelp\> You can also type \<emph\>llint <?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN10322
msgid  "\<image id=\"img_id3154578\" src=\"starmath/res/fo21611.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3154578\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3150161.25
msgid  "Triple Curve Integral"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3150175.26
msgid  "\<ahelp hid=\"HID_SMA_LLLINTX\"\>Inserts a \<emph\>triple curve integral\</emph\> sign with one placeholder.\</ahelp\> You can also type \<emph\>lllint <?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090300.xhp#par_idN1035E
msgid  "\<image id=\"img_id3149332\" src=\"starmath/res/fo21615.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149332\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3145343.33
msgid  "Upper Limit"
msgstr ""

#: text/smath/01/03090300.xhp#par_id3154715.34
msgid  "\<ahelp hid=\"HID_SMA_TOX\"\>Inserts the range statement \<emph\>upper limit\</emph\> for integral and summation with placeholders\</ahelp\> You can also type \<emph\>to <?><?>\</emph\> directly in the \<emph\>Commands\</emph\> window. Limit statements can only be used if combined with the appropriate operators."
msgstr ""

#: text/smath/01/03090300.xhp#par_id3149233.47
msgid  "You can also add limits to an operator (for example, an integral) by first clicking the desired operator and then clicking the \<emph\>limit\</emph\> symbol. This method is faster than typing the commands directly."
msgstr ""

#: text/smath/01/03090300.xhp#par_id3155076.42
msgid  "The command \<emph\>liminf\</emph\> inserts the \<emph\>limit inferior\</emph\> with one placeholder."
msgstr ""

#: text/smath/01/03090300.xhp#par_id3154323.43
msgid  "The command \<emph\>limsup\</emph\> inserts the \<emph\>limit superior\</emph\> with one placeholder."
msgstr ""

#: text/smath/01/03090300.xhp#par_id3146956.45
msgid  "By typing \<emph\>oper\</emph\> in the Commands window, you can insert \<emph\>user-defined operators\</emph\> in $[officename] Math, a feature useful for incorporating special characters into a formula. An example is \<emph\>oper %theta x\</emph\>. Using the \<emph\>oper\</emph\> command, you can also insert characters not in the default $[officename] character set. \<emph\>oper\</emph\> can also be used in connection with limits; for example, \<emph\>oper %union from {i=1} to n x_{i}\</emph\>. In this example, the union symbol is indicated by the name \<emph\>union\</emph\>. However, this is not one of the predefined symbols. To define it, choose \<emph\>Tools - Catalog\</emph\>. select \<emph\>Special\</emph\> as the symbol set in the dialog that appears, then click the \<emph\>Edit\</emph\> button. In the next dialog, select \<emph\>Special\</emph\> as the symbol set again. Enter a meaningful name in the \<emph\>Symbol\</emph\> text box, for example, \"union\" and then click the union symbol in the set of symbols. Click \<emph\>Add\</emph\> and then \<emph\>OK\</emph\>. Click \<emph\>Close\</emph\> to close the \<emph\>Symbols\</emph\> dialog. You are now finished and can type the union symbol in the Commands window, by entering \<emph\>oper %union\</emph\>."
msgstr ""

#: text/smath/01/03090300.xhp#par_id3154243.48
msgid  "Limits can be arranged in ways other than centered above/below the operator. Use the options provided by $[officename] Math for working with superscript and subscript indexes. For example, type \<emph\>sum_a^b c\</emph\> in the Commands window to arrange the limits to the right of the sum symbol. If your limit entries contain longer expressions, you must put them in group brackets, for example, sum_{i=1}^{2*n} b. When formulas are imported from older versions this is done automatically. To change the spacing (gaps) between the characters choose \<emph\>Format - Spacing - Category - \</emph\>\<link href=\"text/smath/01/05030000.xhp\" name=\"Indexes\"\>\<emph\>Indexes\</emph\>\</link\> or \<emph\>Format - Spacing - Category - \</emph\>\<link href=\"text/smath/01/05030000.xhp\" name=\"Limits\"\>\<emph\>Limits\</emph\>\</link\>. Additional basic information about indexes is given elsewhere in the \<link href=\"text/smath/01/03091200.xhp\" name=\"Help\"\>Help\</link\>."
msgstr ""

#: text/smath/01/03090300.xhp#par_id3155956.46
msgid  "When you type information manually in the Commands window, note that a number of operators require spaces for correct structure. This is especially true when your operators are supplied with values instead of placeholders, for example, lim a_{n}=a."
msgstr ""

#: text/smath/01/03090400.xhp#tit
msgid  "Functions"
msgstr ""

#: text/smath/01/03090400.xhp#bm_id3150932
msgid  "\<bookmark_value\>functions; in $[officename] Math\</bookmark_value\>\<bookmark_value\>natural exponential functions\</bookmark_value\>\<bookmark_value\>natural logarithms\</bookmark_value\>\<bookmark_value\>exponential functions\</bookmark_value\>\<bookmark_value\>logarithms\</bookmark_value\>\<bookmark_value\>variables; with right exponents\</bookmark_value\>\<bookmark_value\>exponents; variables with right\</bookmark_value\>\<bookmark_value\>trigonometrical functions\</bookmark_value\>\<bookmark_value\>sine function\</bookmark_value\>\<bookmark_value\>cosine function\</bookmark_value\>\<bookmark_value\>cotangent function\</bookmark_value\>\<bookmark_value\>hyperbolic sine function\</bookmark_value\>\<bookmark_value\>square roots\</bookmark_value\>\<bookmark_value\>hyperbolic cosine function\</bookmark_value\>\<bookmark_value\>hyperbolic tangent function\</bookmark_value\>\<bookmark_value\>hyperbolic cotangent function\</bookmark_value\>\<bookmark_value\>roots\</bookmark_value\>\<bookmark_value\>arc sine function\</bookmark_value\>\<bookmark_value\>arc cosine function\</bookmark_value\>\<bookmark_value\>arc cotangent function\</bookmark_value\>\<bookmark_value\>absolute values\</bookmark_value\>\<bookmark_value\>area hyperbolic cosine function\</bookmark_value\>\<bookmark_value\>area hyperbolic tangent function\</bookmark_value\>\<bookmark_value\>area hyperbolic cotangent function\</bookmark_value\>\<bookmark_value\>factorial\</bookmark_value\>\<bookmark_value\>values; absolute\</bookmark_value\>\<bookmark_value\>tangent function\</bookmark_value\>"
msgstr ""

#: text/smath/01/03090400.xhp#hd_id3150932.1
msgid  "\<link href=\"text/smath/01/03090400.xhp\" name=\"Functions\"\>Functions\</link\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3155374.2
msgid  "\<ahelp hid=\"HID_SMA_FUNCTIONS_CAT\"\>Choose a function in the lower part of the window.\</ahelp\> These functions are also listed in the \<link href=\"text/shared/00/00000001.xhp#kontextmenue\" name=\"context menu\"\>context menu\</link\> of the \<emph\>Commands\</emph\> window. Any functions not contained in the Elements window need to be typed manually in the Commands window."
msgstr ""

#: text/smath/01/03090400.xhp#par_id3150760.3
msgid  "The following is a list of all functions that appear in the \<emph\>Elements\</emph\> window. The icon next to the function indicates that it can be accessed through the Elements window (menu View - Elements) or through the context menu of the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#hd_id3156319.4
msgid  "List of functions"
msgstr ""

#: text/smath/01/03090400.xhp#par_idN10081
msgid  "\<image id=\"img_id3153154\" src=\"starmath/res/fu21505.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3153154\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3149750.44
msgid  "Natural Exponential Function"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3147254.43
msgid  "\<ahelp hid=\"HID_SMA_EX\"\>Inserts a natural exponential function.\</ahelp\> You can also type \<emph\>func e^<?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN100BC
msgid  "\<image id=\"img_id3147507\" src=\"starmath/res/fu21506.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3147507\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3154104.27
msgid  "Natural Logarithm"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3152947.45
msgid  "\<ahelp hid=\"HID_SMA_LNX\"\>Inserts a natural (base e) logarithm with one placeholder.\</ahelp\> You can also type \<emph\>ln(<?>) \</emph\>in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN100F7
msgid  "\<image id=\"img_id3154574\" src=\"starmath/res/fu21507.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154574\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3150972.47
msgid  "Exponential Function"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3151309.46
msgid  "\<ahelp hid=\"HID_SMA_EXPX\"\>Inserts an exponential function with one placeholder.\</ahelp\> You can also type \<emph\>exp(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN10132
msgid  "\<image id=\"img_id3149687\" src=\"starmath/res/fu21508.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149687\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3146925.29
msgid  "Logarithm"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3159190.48
msgid  "\<ahelp hid=\"HID_SMA_LOGX\"\>Inserts a common (base 10) logarithm with one placeholder.\</ahelp\> You can also type \<emph\>log(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_id3149483
msgid  "\<image id=\"img_id3149490\" src=\"starmath/res/fu21908.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149490\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3149819.71
msgid  "Power"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3151250.70
msgid  "\<ahelp hid=\".\"\>Inserts x raised to the yth power.\</ahelp\> You can also type \<emph\><?>^{<?>}\</emph\> in the \<emph\>Commands\</emph\> window. You can replace the \<emph\>^\</emph\> character with \<emph\>rsup\</emph\> or \<emph\>sup\</emph\>."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN101B1
msgid  "\<image id=\"img_id3149043\" src=\"starmath/res/fu21509.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149043\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3152774.5
msgid  "Sine"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3147325.49
msgid  "\<ahelp hid=\"HID_SMA_SINX\"\>Inserts a sine function with one placeholder.\</ahelp\> You can also type \<emph\>sin(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN101EA
msgid  "\<image id=\"img_id3147139\" src=\"starmath/res/fu21510.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3147139\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3150581.7
msgid  "Cosine"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3151027.50
msgid  "\<ahelp hid=\"HID_SMA_COSX\"\>Inserts a cosine function with one placeholder.\</ahelp\> You can also type \<emph\>cos(<?>) \</emph\>in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN10223
msgid  "\<image id=\"img_id3148759\" src=\"starmath/res/fu21511.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3148759\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3156366.9
msgid  "Tangent"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3156379.51
msgid  "\<ahelp hid=\"HID_SMA_TANX\"\>Inserts a tangent function with one placeholder.\</ahelp\> You can also type \<emph\>tan<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN1025C
msgid  "\<image id=\"img_id3149536\" src=\"starmath/res/fu21512.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149536\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3155867.11
msgid  "Cotangent"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3150691.52
msgid  "\<ahelp hid=\"HID_SMA_COTX\"\>Inserts a cotangent symbol with a placeholder.\</ahelp\> You can also type \<emph\>cot(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN10295
msgid  "\<image id=\"img_id3147499\" src=\"starmath/res/fu21513.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3147499\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3145119.72
msgid  "Hyperbolic Sine"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3145132.53
msgid  "\<ahelp hid=\"HID_SMA_SINHX\"\>Inserts a hyperbolic sine with one placeholder.\</ahelp\> You can also type \<emph\>sinh(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN102CE
msgid  "\<image id=\"img_id3168610\" src=\"starmath/res/fu21503.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3168610\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3147734.17
msgid  "Square Root"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3147746.41
msgid  "\<ahelp hid=\"HID_SMA_SQRTX\"\>Inserts a square root symbol with one placeholder.\</ahelp\> You can also type \<emph\>sqrt(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN10309
msgid  "\<image id=\"img_id3147608\" src=\"starmath/res/fu21514.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3147608\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3148846.73
msgid  "Hyperbolic Cosine"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3148857.54
msgid  "\<ahelp hid=\"HID_SMA_COSHX\"\>Inserts a hyperbolic cosine symbol with one placeholder.\</ahelp\> You can also type \<emph\>cosh(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN10342
msgid  "\<image id=\"img_id3151087\" src=\"starmath/res/fu21515.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151087\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3154088.74
msgid  "Hyperbolic Tangent"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3153791.55
msgid  "\<ahelp hid=\"HID_SMA_TANHX\"\>Inserts a hyperbolic tangent symbol with one placeholder.\</ahelp\> You can also type \<emph\>tanh(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN1037C
msgid  "\<image id=\"img_id3151112\" src=\"starmath/res/fu21516.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151112\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3156119.75
msgid  "Hyperbolic Cotangent"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3156131.56
msgid  "\<ahelp hid=\"HID_SMA_COTHX\"\>Inserts a hyperbolic cotangent symbol with one placeholder.\</ahelp\> You can directly type \<emph\>coth(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN103B5
msgid  "\<image id=\"img_id3154714\" src=\"starmath/res/fu21504.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154714\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3149320.19
msgid  "nth Root"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3155578.42
msgid  "\<ahelp hid=\"HID_SMA_NROOTXY\"\>Inserts an nth root function with two placeholders.\</ahelp\> You can also type \<emph\>nroot n x\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN103EE
msgid  "\<image id=\"img_id3145633\" src=\"starmath/res/fu21517.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3145633\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3155083.21
msgid  "Arc Sine"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3149236.57
msgid  "\<ahelp hid=\"HID_SMA_ARCSINX\"\>Inserts an arc sine function with one placeholder.\</ahelp\> You can also type \<emph\>arcsin(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN10427
msgid  "\<image id=\"img_id3146951\" src=\"starmath/res/fu21518.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3146951\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3148792.23
msgid  "Arc Cosine"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3149991.58
msgid  "\<ahelp hid=\"HID_SMA_ARCCOSX\"\>Inserts an arc cosine symbol with one placeholder.\</ahelp\> You can also type \<emph\>arccos(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN10460
msgid  "\<image id=\"img_id3149369\" src=\"starmath/res/fu21519.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149369\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3151224.76
msgid  "Arc Tangent"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3155790.59
msgid  "\<ahelp hid=\"HID_SMA_ARCTANX\"\>Inserts an arc tangent function with one placeholder.\</ahelp\> You can also type \<emph\>arctan(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN10493
msgid  "\<image id=\"img_id3153141\" src=\"starmath/res/fu21520.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3153141\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3148819.25
msgid  "Arc Cotangent"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3151006.60
msgid  "\<ahelp hid=\"HID_SMA_ARCCOTX\"\>Inserts an arc cotangent function with one placeholder.\</ahelp\> You can directly type \<emph\>arccot(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN104CC
msgid  "\<image id=\"img_id3154624\" src=\"starmath/res/fu21501.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154624\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3147383.13
msgid  "Absolute Value"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3147395.39
msgid  "\<ahelp hid=\"HID_SMA_ABSX\"\>Inserts an absolute value sign with one placeholder.\</ahelp\> You can also type \<emph\>abs(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN10507
msgid  "\<image id=\"img_id3154023\" src=\"starmath/res/fu21521.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154023\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3149972.62
msgid  "Area Hyperbolic Sine"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3154671.61
msgid  "\<ahelp hid=\"HID_SMA_ARSINHX\"\>Inserts an area hyperbolic sine function with one placeholder.\</ahelp\> You can also type \<emph\>arsinh(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN1053A
msgid  "\<image id=\"img_id3149602\" src=\"starmath/res/fu21522.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149602\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3150788.64
msgid  "Area Hyperbolic Cosine"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3145652.63
msgid  "\<ahelp hid=\"HID_SMA_ARCOSHX\"\>Inserts an area hyperbolic cosine function with one placeholder.\</ahelp\> You can also type \<emph\>arcosh(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN10573
msgid  "\<image id=\"img_id3155342\" src=\"starmath/res/fu21523.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155342\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3149526.66
msgid  "Area Hyperbolic Tangent"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3155536.65
msgid  "\<ahelp hid=\"HID_SMA_ARTANHX\"\>Inserts an area hyperbolic tangent function with one placeholder.\</ahelp\> You can also type \<emph\>artanh(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN105AC
msgid  "\<image id=\"img_id3150842\" src=\"starmath/res/fu21524.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150842\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3145231.68
msgid  "Area Hyperbolic Cotangent"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3154207.67
msgid  "\<ahelp hid=\"HID_SMA_ARCOTHX\"\>Inserts an area hyperbolic cotangent function with one placeholder.\</ahelp\> You can also type \<emph\>arcoth(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_idN105E5
msgid  "\<image id=\"img_id3145301\" src=\"starmath/res/fu21502.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3145301\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3156006.15
msgid  "Factorial"
msgstr ""

#: text/smath/01/03090400.xhp#par_id3156019.40
msgid  "\<ahelp hid=\"HID_SMA_FACTX\"\>Inserts the factorial sign with one placeholder.\</ahelp\> You can directly type \<emph\>fact <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090400.xhp#par_id3147546.38
msgid  "You can also assign an index or an exponent to a function. For example, typing \<emph\>sin^2x\</emph\> results in in a function \"sine to the power of 2x\"."
msgstr ""

#: text/smath/01/03090400.xhp#par_id3154752.69
msgid  "When typing functions manually in the Commands window, note that spaces are required for some functions (for example, abs 5=5 ; abs -3=3)."
msgstr ""

#: text/smath/01/03090500.xhp#tit
msgid  "Brackets"
msgstr ""

#: text/smath/01/03090500.xhp#bm_id3153153
msgid  "\<bookmark_value\>brackets; in $[officename] Math\</bookmark_value\>\<bookmark_value\>brackets; round (Math)\</bookmark_value\>\<bookmark_value\>parentheses (Math)\</bookmark_value\>\<bookmark_value\>brackets; square (Math)\</bookmark_value\>\<bookmark_value\>brackets; double square (Math)\</bookmark_value\>\<bookmark_value\>braces in %PRODUCTNAME Math\</bookmark_value\>\<bookmark_value\>brackets; angle (Math)\</bookmark_value\>\<bookmark_value\>brackets; operator (Math)\</bookmark_value\>\<bookmark_value\>brackets; angle with operator\</bookmark_value\>\<bookmark_value\>brackets; group\</bookmark_value\>\<bookmark_value\>grouping brackets\</bookmark_value\>\<bookmark_value\>round brackets\</bookmark_value\>\<bookmark_value\>square brackets\</bookmark_value\>\<bookmark_value\>double square brackets; scalable\</bookmark_value\>\<bookmark_value\>scalable braces\</bookmark_value\>\<bookmark_value\>scalable round brackets\</bookmark_value\>\<bookmark_value\>scalable lines with ceiling\</bookmark_value\>\<bookmark_value\>vertical bars\</bookmark_value\>\<bookmark_value\>brackets; scalable\</bookmark_value\>\<bookmark_value\>operator brackets\</bookmark_value\>\<bookmark_value\>floor brackets\</bookmark_value\>\<bookmark_value\>lines; with edges\</bookmark_value\>\<bookmark_value\>ceiling brackets; lines with\</bookmark_value\>\<bookmark_value\>lines; scalable\</bookmark_value\>\<bookmark_value\>ceiling brackets;scalable lines with\</bookmark_value\>\<bookmark_value\>brackets; single, without group function\</bookmark_value\>\<bookmark_value\>single brackets without group function\</bookmark_value\>\<bookmark_value\>brackets;widowed\</bookmark_value\>\<bookmark_value\>widowed brackets\</bookmark_value\>\<bookmark_value\>orphaned brackets\</bookmark_value\>"
msgstr ""

#: text/smath/01/03090500.xhp#hd_id3153153.1
msgid  "\<link href=\"text/smath/01/03090500.xhp\" name=\"Brackets\"\>Brackets\</link\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3147258.2
msgid  "\<ahelp hid=\"HID_SMA_BRACKETS_CAT\"\>You can choose among various bracket types to structure a \<emph\>$[officename] Math\</emph\> formula. Bracket types are displayed in the lower part of the Elements window.\</ahelp\> These brackets are also listed in the \<link href=\"text/shared/00/00000001.xhp#kontextmenue\" name=\"context menu\"\>context menu\</link\> of the \<emph\>Commands\</emph\> window. All brackets that are not contained in the Elements window or in the context menu can be typed manually in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#par_id3154264.3
msgid  "The following is a complete list of all available bracket types. The icon next to the bracket type indicates that it can be accessed through the Elements window (menu View - Elements) or through the context menu of the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#hd_id3154277.4
msgid  "Bracket types"
msgstr ""

#: text/smath/01/03090500.xhp#par_idN10084
msgid  "\<image id=\"img_id3149801\" src=\"starmath/res/al21801.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3149801\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3153778.7
msgid  "Round brackets (parentheses)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3151102.8
msgid  "\<ahelp hid=\"HID_SMA_LRPARENTX\"\>Inserts a placeholder within normal round brackets (parentheses).\</ahelp\> You can also type \<emph\>(<?>)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN100BF
msgid  "\<image id=\"img_id3158440\" src=\"starmath/res/al21802.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3158440\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3151319.33
msgid  "Square brackets"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3150356.32
msgid  "\<ahelp hid=\"HID_SMA_LRBRACKETX\"\>Inserts a placeholder within square brackets.\</ahelp\> You can also type \<emph\>[<?>]\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN100F8
msgid  "\<image id=\"img_id3146923\" src=\"starmath/res/al21823.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3146923\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3149300.52
msgid  "Double square brackets"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3155175.51
msgid  "\<ahelp hid=\"HID_SMA_LRDBRACKETX\"\>Inserts a placeholder within double square brackets.\</ahelp\> You can also type \<emph\>ldbracket <?> rdbracket\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN10131
msgid  "\<image id=\"img_id3149815\" src=\"starmath/res/al21804.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3149815\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3147088.37
msgid  "Braces (curly brackets)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3147101.36
msgid  "\<ahelp hid=\"HID_SMA_LRBRACEX\"\>Inserts a placeholder withing braces (curly brackets).\</ahelp\> You can also type \<emph\>lbrace<?>rbrace\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN1016C
msgid  "\<image id=\"img_id3148736\" src=\"starmath/res/al21805.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3148736\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3147336.60
msgid  "Single vertical bars"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3155146.38
msgid  "\<ahelp hid=\"HID_SMA_LRLINEX\"\>Inserts a placeholder within vertical bars.\</ahelp\> You can also type \<emph\>lline <?> rline\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN101A5
msgid  "\<image id=\"img_id3153350\" src=\"starmath/res/al21806.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3153350\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3151039.40
msgid  "Double vertical bars"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3149175.39
msgid  "\<ahelp hid=\"HID_SMA_LRDLINEX\"\>Inserts a placeholder within double vertical bars.\</ahelp\> You can also type \<emph\>ldline <?> rdline\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN101DE
msgid  "\<image id=\"img_id3155118\" src=\"starmath/res/al21803.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3155118\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3147315.35
msgid  "Angle brackets"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3155913.34
msgid  "\<ahelp hid=\"HID_SMA_LRANGLEX\"\>Inserts a placeholder within angle brackets.\</ahelp\> You can also type \<emph\>langle <?> rangle\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN10217
msgid  "\<image id=\"img_id3155867\" src=\"starmath/res/al21821.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3155867\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3147413.48
msgid  "Operator brackets"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3147425.47
msgid  "\<ahelp hid=\"HID_SMA_LMRANGLEXY\"\>Inserts a placeholder within operator brackets.\</ahelp\> You can also type \<emph\>langle <?> mline <?> rangle\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN10253
msgid  "\<image id=\"img_id3149561\" src=\"starmath/res/al21808.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3149561\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3155964.42
msgid  "Group brackets"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3155976.41
msgid  "\<ahelp hid=\"HID_SMA_LRGROUPX\"\>Inserts group brackets.\</ahelp\> You can also type \<emph\>{<?>}\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN1028E
msgid  "\<image id=\"img_id3147733\" src=\"starmath/res/al21809.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3147733\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3146333.9
msgid  "Round brackets (scalable)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3146345.10
msgid  "\<ahelp hid=\"HID_SMA_SLRPARENTX\"\>Inserts \<emph\>scalable rounded brackets\</emph\> with one placeholder.\</ahelp\> You can also type \<emph\>left(<?> right)\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN102CC
msgid  "\<image id=\"img_id3148852\" src=\"starmath/res/al21810.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3148852\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3155570.11
msgid  "Square brackets (scalable)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3148438.12
msgid  "\<ahelp hid=\"HID_SMA_SLRBRACKETX\"\>Inserts scalable square brackets with placeholders.\</ahelp\> You can also type \<emph\>left[<?> right]\</emph\> in the \<emph\>Commands\</emph\> window. The size of the brackets is adjusted automatically."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN10307
msgid  "\<image id=\"img_id3153794\" src=\"starmath/res/al21824.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3153794\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3154589.54
msgid  "Double square brackets (scalable)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3150161.53
msgid  "\<ahelp hid=\"HID_SMA_SLRDBRACKETX\"\>Inserts scalable double square brackets with placeholders.\</ahelp\> You can also type \<emph\>left ldbracket <?> right rdbracket\</emph\> directly in the \<emph\>Commands\</emph\> window. The bracket size is adjusted automatically."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN10342
msgid  "\<image id=\"img_id3153972\" src=\"starmath/res/al21812.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3153972\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3154712.13
msgid  "Braces (scalable)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3154724.14
msgid  "\<ahelp hid=\"HID_SMA_SLRBRACEX\"\>Inserts scalable braces with a placeholder.\</ahelp\> You can also type \<emph\>left lbrace <?> right rbrace\</emph\> in the \<emph\>Commands\</emph\> window. The size of the braces is automatically adjusted."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN1037E
msgid  "\<image id=\"img_id3155598\" src=\"starmath/res/al21813.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155598\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3150924.61
msgid  "Single vertical bars (scalable)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3145634.18
msgid  "\<ahelp hid=\"HID_SMA_SLRLINEX\"\>Inserts scalable single vertical bars with a placeholder.\</ahelp\> You can also type \<emph\>left lline <?> right rline\</emph\> in the \<emph\>Commands\</emph\> window. The size of the brackets is automatically adjusted."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN103B7
msgid  "\<image id=\"img_id3153223\" src=\"starmath/res/al21814.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3153223\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3146938.17
msgid  "Double vertical bars (scalable)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3146950.20
msgid  "\<ahelp hid=\"HID_SMA_SLRDLINEX\"\>Inserts scalable double vertical bars with a placeholder.\</ahelp\> You can also type \<emph\>left ldline <?> right rdline\</emph\> in the \<emph\>Commands\</emph\> window. The size of the brackets is automatically adjusted."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN103F0
msgid  "\<image id=\"img_id3150026\" src=\"starmath/res/al21811.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150026\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3149359.15
msgid  "Angle brackets (scalable)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3149372.16
msgid  "\<ahelp hid=\"HID_SMA_SLRANGLEX\"\>Inserts scalable angle brackets with a placeholder.\</ahelp\> You can also type \<emph\>left langle <?> right rangle\</emph\> in the \<emph\>Commands\</emph\> window. The size of the brackets is automatically adjusted."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN10429
msgid  "\<image id=\"img_id3154235\" src=\"starmath/res/al21822.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3154235\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3153139.50
msgid  "Operator brackets (scalable)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3155388.49
msgid  "\<ahelp hid=\"HID_SMA_SLMRANGLEXY\"\>Inserts scalable operator brackets with placeholders.\</ahelp\> You can also type \<emph\>left langle <?> mline <?> right rangle\</emph\> in the \<emph\>Commands\</emph\> window. The bracket size is adjusted automatically."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN10464
msgid  "\<image id=\"img_id3154349\" src=\"starmath/res/al21825.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3154349\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3155954.56
msgid  "Brace top (scalable)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3154621.55
msgid  "\<ahelp hid=\"HID_SMA_XOVERBRACEY\"\>Inserts a scalable horizontal upper brace with placeholders.\</ahelp\> You can also enter \<emph\><?> overbrace <?>\</emph\> directly in the \<emph\>Commands\</emph\> window. The bracket size is adjusted automatically."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN104A0
msgid  "\<image id=\"img_id3149646\" src=\"starmath/res/al21826.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3149646\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3150674.58
msgid  "Brace bottom (scalable)"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3154023.57
msgid  "\<ahelp hid=\"HID_SMA_XUNDERBRACEY\"\>Inserts a scalable horizontal lower brace with placeholders.\</ahelp\> You can also type \<emph\><?> underbrace <?>\</emph\> directly in the \<emph\>Commands\</emph\> window. The bracket size is adjusted automatically."
msgstr ""

#: text/smath/01/03090500.xhp#par_id3149954.27
msgid  "\<ahelp hid=\"HID_SMA_LRFLOORX\"\>To insert floor brackets, type \<emph\>lfloor<?>rfloor\</emph\> directly in the \<emph\>Commands\</emph\> window.\</ahelp\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3150592.28
msgid  "\<ahelp hid=\"HID_SMA_LRCEILX\"\>To insert ceiling brackets, type \<emph\>lceil<?>rceil\</emph\> directly in the \<emph\>Commands\</emph\> window.\</ahelp\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3149623.45
msgid  "\<ahelp hid=\"HID_SMA_SLRFLOORX\"\>To insert scalable floor brackets, type \<emph\>left lfloor<?>right rfloor\</emph\> directly in the \<emph\>Commands\</emph\> window.\</ahelp\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3145668.46
msgid  "\<ahelp hid=\"HID_SMA_SLRCEILX\"\>To insert scalable ceiling brackets, type \<emph\>left lceil<?>right rceil\</emph\> directly in the \<emph\>Commands\</emph\> window.\</ahelp\>"
msgstr ""

#: text/smath/01/03090500.xhp#par_id3149208.44
msgid  "Brackets are automatically sized when you type \<emph\>left\</emph\> and \<emph\>right\</emph\> in front of the bracket command, for example, \<emph\>left(a over b right)\</emph\>. You can also set the size and spacing of brackets by choosing \<emph\>Format - Spacing - Category - Brackets\</emph\> and setting the desired percentages. Mark the \<emph\>Scale all brackets\</emph\> check box to apply the changes to all brackets in the formula."
msgstr ""

#: text/smath/01/03090500.xhp#par_id3150857.43
msgid  "You can also use single brackets. To do this, type a backslash \<emph\>\\\\\</emph\> in front of the command. For example, when you type \<emph\>\\\\[\</emph\>, the left square bracket appears without its counterpart. This is useful for creating reverse brackets or for constructing intervals. Note that only non-scalable brackets can be used individually. To change the size, use the \<emph\>size\</emph\> command."
msgstr ""

#: text/smath/01/03090500.xhp#par_idN113E5
msgid  "Examples of single brackets"
msgstr ""

#: text/smath/01/03090500.xhp#par_idN113E8
msgid  "For non-scaled brackets:"
msgstr ""

#: text/smath/01/03090500.xhp#par_idN113EB
msgid  "a = \\\\{ \\\\( \\\\[ b newline"
msgstr ""

#: text/smath/01/03090500.xhp#par_idN113EE
msgid  "{} + c \\\\] \\\\) \\\\ }"
msgstr ""

#: text/smath/01/03090500.xhp#par_idN113F3
msgid  "For scaled brackets use \<emph\>none\</emph\> as the bracket name"
msgstr ""

#: text/smath/01/03090500.xhp#par_idN113FA
msgid  "a = left ( a over b right none newline"
msgstr ""

#: text/smath/01/03090500.xhp#par_idN113FF
msgid  "left none phantom {a over b} + c right )"
msgstr ""

#: text/smath/01/03090500.xhp#par_idN11404
msgid  "The \<emph\>phantom\</emph\> statement ensures that the last bracket is the correct size."
msgstr ""

#: text/smath/01/03090500.xhp#par_id3145107.29
msgid  "Be sure to put spaces (gaps) between elements when entering them directly in the Commands window. This ensures that the correct structure is recognized."
msgstr ""

#: text/smath/01/03090500.xhp#par_id3153198.31
msgid  "Useful information about \<link href=\"text/smath/01/03091200.xhp\" name=\"indexes and exponents\"\>indexes and exponents\</link\> as well as \<link href=\"text/smath/01/03091400.xhp\" name=\"scaling\"\>scaling\</link\> helps you structure formulas effectively. For more information about brackets, see \<link href=\"text/smath/01/03091100.xhp\" name=\"Brackets and Groups\"\>Brackets and Grouping\</link\>."
msgstr ""

#: text/smath/01/03090600.xhp#tit
msgid  "Attributes"
msgstr ""

#: text/smath/01/03090600.xhp#bm_id3154011
msgid  "\<bookmark_value\>attributes; in %PRODUCTNAME Math\</bookmark_value\>         \<bookmark_value\>formulas; attributes in\</bookmark_value\>         \<bookmark_value\>accents; in %PRODUCTNAME Math\</bookmark_value\>         \<bookmark_value\>attributes; accents\</bookmark_value\>         \<bookmark_value\>vector arrows as attributes\</bookmark_value\>         \<bookmark_value\>tilde as attribute\</bookmark_value\>         \<bookmark_value\>circumflex attribute\</bookmark_value\>         \<bookmark_value\>bold attribute\</bookmark_value\>         \<bookmark_value\>italic attribute in %PRODUCTNAME Math\</bookmark_value\>         \<bookmark_value\>resizing;fonts\</bookmark_value\>         \<bookmark_value\>scaling;fonts\</bookmark_value\>         \<bookmark_value\>attributes; changing fonts\</bookmark_value\>         \<bookmark_value\>changing; fonts\</bookmark_value\>         \<bookmark_value\>attributes; colored characters\</bookmark_value\>         \<bookmark_value\>colored characters\</bookmark_value\>         \<bookmark_value\>attributes; changing defaults\</bookmark_value\>         \<bookmark_value\>circle attribute\</bookmark_value\>         \<bookmark_value\>double dot attribute\</bookmark_value\>         \<bookmark_value\>dot attribute\</bookmark_value\>         \<bookmark_value\>line through attribute\</bookmark_value\>         \<bookmark_value\>line above attribute\</bookmark_value\>         \<bookmark_value\>reversed circumflex attribute\</bookmark_value\>         \<bookmark_value\>overline attribute\</bookmark_value\>         \<bookmark_value\>wide vector arrow attribute\</bookmark_value\>         \<bookmark_value\>wide tilde attribute\</bookmark_value\>         \<bookmark_value\>wide circumflex attribute\</bookmark_value\>         \<bookmark_value\>underline attribute\</bookmark_value\>         \<bookmark_value\>triple dot attribute\</bookmark_value\>         \<bookmark_value\>transparent character as attribute\</bookmark_value\>"
msgstr ""

#: text/smath/01/03090600.xhp#hd_id3154011.1
msgid  "\<variable id=\"attributes\"\>\<link href=\"text/smath/01/03090600.xhp\" name=\"Attributes\"\>Attributes\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3145802.2
msgid  "\<ahelp hid=\"HID_SMA_ATTRIBUTES_CAT\"\>You can choose from various attributes for \<emph\>%PRODUCTNAME\</emph\>            \<emph\>Math\</emph\> formulas. Some attributes are displayed in the lower part of the Elements window.\</ahelp\> These attributes are also listed in the \<link href=\"text/shared/00/00000001.xhp#kontextmenue\" name=\"context menu\"\>context menu\</link\> of the \<emph\>Commands\</emph\> window. All attributes not contained in the Elements window or in the context menu must be typed manually in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_id3155962.3
msgid  "The following is a complete list of all attributes available in \<item type=\"productname\"\>%PRODUCTNAME\</item\> Math. The symbol next to the attribute indicates that it can be accessed through the Elements window (choose \<emph\>View - Elements\</emph\>) or through the context menu of the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_id3149604.4
msgid  "In describing the following attribute functions, the letter \"a\" in the icon refers to the placeholder that you would like to assign to the respective attribute. You can substitute this character with any other character that you choose."
msgstr ""

#: text/smath/01/03090600.xhp#hd_id3154650.5
msgid  "Attribute Functions"
msgstr ""

#: text/smath/01/03090600.xhp#par_idN10098
msgid  "\<image id=\"img_id3150391\" src=\"starmath/res/at21701.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3150391\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3146322.6
msgid  "Acute accent"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3150533.7
msgid  "\<ahelp hid=\"HID_SMA_ACUTEX\"\>Inserts a placeholder with an acute accent.\</ahelp\> You can also type \<emph\>acute <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN100D5
msgid  "\<image id=\"img_id3154504\" src=\"starmath/res/at21702.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3154504\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3149877.22
msgid  "Grave accent"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3150018.23
msgid  "\<ahelp hid=\"HID_SMA_GRAVEX\"\>Inserts a placeholder with a \<emph\>grave accent\</emph\> (grave).\</ahelp\> You can also type \<emph\>grave <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN10115
msgid  "\<image id=\"img_id3155370\" src=\"starmath/res/at21703.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3155370\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3156263.47
msgid  "Reverse Circumflex"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3147167.13
msgid  "\<ahelp hid=\"HID_SMA_CHECKX\"\>Inserts a placeholder with a reverse circumflex (\"checkmark\") over it.\</ahelp\> You can also type \<emph\>check <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN1014E
msgid  "\<image id=\"img_id3145202\" src=\"starmath/res/at21704.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3145202\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3149976.10
msgid  "Breve"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3153619.11
msgid  "\<ahelp hid=\"HID_SMA_BREVEX\"\>Inserts a placeholder with an accent breve.\</ahelp\> You can also type \<emph\>breve <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN10187
msgid  "\<image id=\"img_id3159179\" src=\"starmath/res/at21709.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3159179\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3154258.14
msgid  "Circle"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3153573.15
msgid  "\<ahelp hid=\"HID_SMA_CIRCLEX\"\>Inserts a placeholder with a circle over it.\</ahelp\> You can also type \<emph\>circle <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN101C0
msgid  "\<image id=\"img_id3149808\" src=\"starmath/res/im21106.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3149808\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3153527.28
msgid  "Vector arrow"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3153539.29
msgid  "\<ahelp hid=\"HID_SMA_VECX\"\>Inserts a placeholder with a vector arrow.\</ahelp\> You can also type \<emph\>vec <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN101FB
msgid  "\<image id=\"img_id3153776\" src=\"starmath/res/at21708.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3153776\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3150356.26
msgid  "Tilde"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3154570.27
msgid  "\<ahelp hid=\"HID_SMA_TILDEX\"\>Inserts a placeholder with a tilde.\</ahelp\> You can also type \<emph\>tilde <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN10236
msgid  "\<image id=\"img_id3149695\" src=\"starmath/res/at21707.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3149695\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3154201.24
msgid  "Circumflex"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3159198.25
msgid  "\<ahelp hid=\"HID_SMA_HATX\"\>Inserts a placeholder with a circumflex (\"hat\").\</ahelp\> You can also directly enter \<emph\>hat <?>\</emph\> in the Commands window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN1026E
msgid  "\<image id=\"img_id3148986\" src=\"starmath/res/at21705.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3148986\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3149486.8
msgid  "Line above (bar)"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3149815.9
msgid  "\<ahelp hid=\"HID_SMA_BARX\"\>Inserts a line (\"bar\") above a placeholder .\</ahelp\> You can also type \<emph\>bar <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN102A7
msgid  "\<image id=\"img_id3147095\" src=\"starmath/res/at21710.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3147095\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3147221.16
msgid  "Dot"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3154900.17
msgid  "\<ahelp hid=\"HID_SMA_DOTX\"\>Inserts a placeholder with a dot over it.\</ahelp\> You can also type \<emph\>dot <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN102E0
msgid  "\<image id=\"img_id3147328\" src=\"starmath/res/at21724.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3147328\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3153516.54
msgid  "Wide vector arrow"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3147126.53
msgid  "\<ahelp hid=\"HID_SMA_WIDEVECX\"\>Inserts a wide vector arrow with a placeholder.\</ahelp\> You can also type \<emph\>widevec\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN10319
msgid  "\<image id=\"img_id3153359\" src=\"starmath/res/at21723.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3153359\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3156278.56
msgid  "Wide tilde"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3154116.55
msgid  "\<ahelp hid=\"HID_SMA_WIDETILDEX\"\>Inserts a wide tilde with a placeholder. \</ahelp\> You can also type \<emph\>widetilde\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN10352
msgid  "\<image id=\"img_id3155117\" src=\"starmath/res/at21722.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3155117\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3148764.58
msgid  "Wide circumflex"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3147311.57
msgid  "\<ahelp hid=\"HID_SMA_WIDEHATX\"\>Inserts a wide circumflex (\"hat\") with a placeholder. \</ahelp\> You can also type \<emph\>widehat\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN1038B
msgid  "\<image id=\"img_id3148873\" src=\"starmath/res/at21711.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3148873\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3155921.18
msgid  "Double dot"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3149541.19
msgid  "\<ahelp hid=\"HID_SMA_DDOTX\"\>Inserts a placeholder with two dots over it.\</ahelp\> You can also directly enter \<emph\>ddot <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN103C4
msgid  "\<image id=\"img_id3147424\" src=\"starmath/res/at21713.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3147424\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3147621.32
msgid  "Line over"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3147492.33
msgid  "\<ahelp hid=\"HID_SMA_OVERLINEX\"\>Inserts a line over a placeholder.\</ahelp\> You can also type \<emph\>overline <?\</emph\>                  \<emph\>>\</emph\> in the \<emph\>Commands\</emph\> window. The line adjusts itself to correct length."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN103FD
msgid  "\<image id=\"img_id3145130\" src=\"starmath/res/at21714.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3145130\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3153258.30
msgid  "Line below"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3153269.59
msgid  "\<ahelp hid=\"HID_SMA_UNDERLINEX\"\>Inserts a line below a placeholder.\</ahelp\> You can also type \<emph\>underline <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN10436
msgid  "\<image id=\"img_id3145318\" src=\"starmath/res/at21715.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3145318\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3153292.34
msgid  "Line through (overstrike)"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3153304.35
msgid  "\<ahelp hid=\"HID_SMA_OVERSTRIKEX\"\>Inserts a placeholder with a line (or overstrike) through it.\</ahelp\> You can also type \<emph\>overstrike <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN1046F
msgid  "\<image id=\"img_id3156104\" src=\"starmath/res/at21712.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3156104\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3154707.20
msgid  "Triple dot"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3154718.21
msgid  "\<ahelp hid=\"HID_SMA_DDDOTX\"\>Inserts three dots over a placeholder.\</ahelp\> You can also type \<emph\>dddot <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN104A8
msgid  "\<image id=\"img_id3145626\" src=\"starmath/res/at21716.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3145626\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3149774.40
msgid  "Transparent"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3155074.41
msgid  "\<ahelp hid=\"HID_SMA_PHANTOMX\"\>Inserts a placeholder for a transparent character. This character takes up the space of \"a\" but does not display it.\</ahelp\> You can also type \<emph\>phantom <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN104E1
msgid  "\<image id=\"img_id3153240\" src=\"res/commandimagelist/sc_bold.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3153240\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3150089.38
msgid  "Bold font"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3150101.39
msgid  "\<ahelp hid=\"HID_SMA_BOLDX\"\>Inserts a placeholder with bold formatting.\</ahelp\> You can also type \<emph\>bold <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN1051C
msgid  "\<image id=\"img_id3150038\" src=\"res/commandimagelist/sc_italic.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3150038\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3147344.36
msgid  "Italic font"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3147355.37
msgid  "\<ahelp hid=\"HID_SMA_ITALX\"\>Inserts a placeholder with italic formatting.\</ahelp\> You can also type \<emph\>ital <?>\</emph\> or \<emph\>italic <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN1055A
msgid  "\<image id=\"img_id3155801\" src=\"res/commandimagelist/sc_fontheight.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3155801\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3145618.44
msgid  "Resize"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3153125.45
msgid  "\<ahelp hid=\"HID_SMA_SIZEXY\"\>Inserts a command for modifying the font size with two placeholders. The first placeholder refers to the font size (for example, 12) and the second one contains the text.\</ahelp\> For proper structure, insert a space between the values. You can also directly enter \<emph\>size <?> <?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_idN10595
msgid  "\<image id=\"img_id3148804\" src=\"res/commandimagelist/sc_charfontname.png\" width=\"0.2228in\" height=\"0.2228in\"\>\<alt id=\"alt_id3148804\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3154359.42
msgid  "Change font"
msgstr ""

#: text/smath/01/03090600.xhp#par_id3154371.43
msgid  "\<ahelp hid=\"HID_SMA_FONTXY\"\>Inserts a command for changing the font type, with two placeholders. Replace the first placeholder with the name of one of the \<link href=\"text/smath/01/05010000.xhp\" name=\"custom fonts\"\>custom fonts\</link\>, \<emph\>Serif, Sans\</emph\> or \<emph\>Fixed\</emph\>. Replace the second placeholder with the text.\</ahelp\> You can also type \<emph\>font <?> <?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090600.xhp#par_id3149626.48
msgid  " Use the \<emph\>color\</emph\> command to change the color of your formula. Type \<emph\>color\</emph\>, then type the color name (the available colors are white, black, cyan, magenta, red, blue, green and yellow), then the formula, character or character sequence. The input \<emph\>color green size 20 a\</emph\> results in a green letter \"a\" with a font size of 20."
msgstr ""

#: text/smath/01/03090600.xhp#par_id3146071.51
msgid  "The \<emph\>nbold\</emph\> and \<emph\>nitalic\</emph\> commands remove the bold or italic default fonts of formula components. For example, remove italics from the x in the formula 5 x + 3=28 by typing \<emph\>nitalic\</emph\> before the x as in \<emph\>5 nitalic x + 3=28\</emph\>."
msgstr ""

#: text/smath/01/03090600.xhp#par_id3150612.46
msgid  "The \<link href=\"text/smath/01/03091300.xhp\" name=\"attributes\"\>attributes\</link\> \"acute\", \"bar\", \"breve\", \"check\", \"circle\", \"dot\", \"ddot\", \"dddot\", \"grave\", \"hat\", \"tilde\" and \"vec\" have fixed sizes. Their width or length cannot be adjusted when positioned over a long symbol."
msgstr ""

#: text/smath/01/03090600.xhp#par_id3155621.52
msgid  "For size changes you can use \<emph\>size n\</emph\>,\<emph\> +n\</emph\>,\<emph\> -n\</emph\>,\<emph\> *n\</emph\> and\<emph\> /n \</emph\>, where \<emph\>n\</emph\> is a placeholder. This method is useful when the base size of the formula is subject to change. The commands \<emph\>size +n\</emph\> and \<emph\>size -n\</emph\> change point size, and \<emph\>size *n\</emph\> and \<emph\>size /n\</emph\> change the size by a percentage. For example, the command \<emph\>size *1.17\</emph\> increases the size of a character by exactly 17%."
msgstr ""

#: text/smath/01/03090600.xhp#par_id3148695.49
msgid  "Note that some entries require spaces for the correct structure. This is especially true when you specify attributes with fixed values instead of placeholders."
msgstr ""

#: text/smath/01/03090600.xhp#par_id3145230.50
msgid  "For more information about formatting in \<emph\>%PRODUCTNAME\</emph\>         \<emph\>Math\</emph\>, see \<link href=\"text/smath/01/03091100.xhp\" name=\"Brackets and Grouping\"\>Brackets and Grouping\</link\>."
msgstr ""

#: text/smath/01/03090600.xhp#par_id3154221.31
msgid  "Information on \<link href=\"text/smath/01/03091300.xhp\" name=\"attributes\"\>attributes\</link\>, \<link href=\"text/smath/01/03091200.xhp\" name=\"indexes and exponents\"\>indexes and exponents\</link\>, and \<link href=\"text/smath/01/03091400.xhp\" name=\"scaling\"\>scaling\</link\> can help you structure your documents more efficiently."
msgstr ""

#: text/smath/01/03090700.xhp#tit
msgid  "Format"
msgstr ""

#: text/smath/01/03090700.xhp#bm_id3153150
msgid  "\<bookmark_value\>formatting;in $[officename] Math\</bookmark_value\>\<bookmark_value\>$[officename] Math; formatting\</bookmark_value\>\<bookmark_value\>superscripts\</bookmark_value\>\<bookmark_value\>binomials\</bookmark_value\>\<bookmark_value\>vertical elements\</bookmark_value\>\<bookmark_value\>lines; inserting in formulas\</bookmark_value\>\<bookmark_value\>subscripts\</bookmark_value\>\<bookmark_value\>stacks\</bookmark_value\>\<bookmark_value\>vertical arrangement of elements\</bookmark_value\>\<bookmark_value\>small gaps\</bookmark_value\>\<bookmark_value\>alignment; left (Math)\</bookmark_value\>\<bookmark_value\>left-justified alignment (Math)\</bookmark_value\>\<bookmark_value\>alignment; horizontally centered (Math)\</bookmark_value\>\<bookmark_value\>centered horizontally; alignment (Math)\</bookmark_value\>\<bookmark_value\>alignment; right (Math)\</bookmark_value\>\<bookmark_value\>right-justified alignment in %PRODUCTNAME Math\</bookmark_value\>\<bookmark_value\>matrices; arranging\</bookmark_value\>\<bookmark_value\>spaces in formulas\</bookmark_value\>\<bookmark_value\>gaps in formulas\</bookmark_value\>\<bookmark_value\>inserting; gaps\</bookmark_value\>\<bookmark_value\>arranging;matrices\</bookmark_value\>\<bookmark_value\>formulas;aligning\</bookmark_value\>\<bookmark_value\>aligning formulas\</bookmark_value\>"
msgstr ""

#: text/smath/01/03090700.xhp#hd_id3153150.1
msgid  "\<link href=\"text/smath/01/03090700.xhp\" name=\"Format\"\>Format\</link\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3147262.2
msgid  "\<ahelp hid=\"HID_SMA_FORMAT_CAT\"\>You can choose among various options for formatting a $[officename] Math formula. The format options are displayed in the lower half of the Formula Elements window.\</ahelp\> These options are also listed in the \<link href=\"text/shared/00/00000001.xhp#kontextmenue\" name=\"context menu\"\>context menu\</link\> of the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_id3154263.3
msgid  "The following is a complete list of all available formatting options in $[officename] Math. The icon next to the formatting option indicates that it can be accessed through the Elements window (menu \<emph\>View - Elements\</emph\>) or through the context menu of the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_id3153536.17
msgid  "The letter \"a\" refers to the placeholder in your formula which you would like to assign to the respective formatting. You can substitute this character for any other you like."
msgstr ""

#: text/smath/01/03090700.xhp#hd_id3151104.4
msgid  "Formatting options"
msgstr ""

#: text/smath/01/03090700.xhp#par_idN1008B
msgid  "\<image id=\"img_id3150981\" src=\"starmath/res/co21916.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150981\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3147519.45
msgid  "Superscript left"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3147531.44
msgid  "\<ahelp hid=\"HID_SMA_LSUPX\"\>Inserts a superscript to the left of a placeholder.\</ahelp\> You can also type \<emph\><?>lsup{<?>}\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN100C4
msgid  "\<image id=\"img_id3149691\" src=\"starmath/res/co21918.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149691\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3146931.60
msgid  "Superscript top"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3159195.58
msgid  "\<ahelp hid=\"HID_SMA_CSUPX\"\>Inserts a superscript directly above a placeholder.\</ahelp\> You can also type \<emph\><?>csup<?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN100FF
msgid  "\<image id=\"img_id3149097\" src=\"starmath/res/co21908.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149097\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3151249.39
msgid  "Superscript right"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3151262.40
msgid  "\<ahelp hid=\"HID_SMA_RSUPX\"\>Inserts a superscript to the right of a placeholder.\</ahelp\> You can also type \<emph\><?>^{<?>}\</emph\> directly in the \<emph\>Commands\</emph\> window, or you can use \<emph\>rsup\</emph\> or \<emph\>sup\</emph\>."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN1013E
msgid  "\<image id=\"img_id3149044\" src=\"starmath/res/co21905.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149044\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3152774.63
msgid  "Vertical stack (2 elements)"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3147326.62
msgid  "\<ahelp hid=\"HID_SMA_BINOMXY\"\>Inserts a vertical stack (binomial) with two placeholders.\</ahelp\> You can also type \<emph\>binom<?><?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN10179
msgid  "\<image id=\"img_id3154390\" src=\"starmath/res/co21901.png\" width=\"0.2228inch\" height=\"0.2228inch\"\>\<alt id=\"alt_id3154390\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3150575.41
msgid  "New line"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3150587.18
msgid  "\<ahelp hid=\"HID_SMA_NEWLINE\"\>Inserts a new line in your document.\</ahelp\> You can also type \<emph\>newline\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN101B2
msgid  "\<image id=\"img_id3155117\" src=\"starmath/res/co21912.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155117\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3148760.43
msgid  "Subscript left"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3147309.42
msgid  "\<ahelp hid=\"HID_SMA_LSUBX\"\>Inserts a subscript to the left of a placeholder.\</ahelp\> You can also type \<emph\><?>lsub{<?>}\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN101EB
msgid  "\<image id=\"img_id3149544\" src=\"starmath/res/co21917.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149544\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3150687.61
msgid  "Subscript bottom"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3150699.59
msgid  "\<ahelp hid=\"HID_SMA_CSUBX\"\>Inserts a subscript directly under a placeholder.\</ahelp\> You can also type \<emph\><?>csub<?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN10226
msgid  "\<image id=\"img_id3145265\" src=\"starmath/res/co21904.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3145265\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3145136.37
msgid  "Subscript right"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3146913.38
msgid  "\<ahelp hid=\"HID_SMA_RSUBX\"\>Inserts a subscript to the right of a placeholder.\</ahelp\> You can also type \<emph\><?>_{<?>}\</emph\> in the \<emph\>Commands\</emph\> window, and the subscript dash can be replaced by \<emph\>rsub\</emph\> or \<emph\>sub\</emph\>."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN10265
msgid  "\<image id=\"img_id3149220\" src=\"starmath/res/co21906.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149220\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3147116.65
msgid  "Vertical stack (3 elements)"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3146332.64
msgid  "\<ahelp hid=\"HID_SMA_STACK\"\>Inserts a vertical stack with three placeholders.\</ahelp\> You can also type \<emph\>stack {<?>#<?>#<?>}\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN102A0
msgid  "\<image id=\"img_id3149848\" src=\"starmath/res/co21902.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149848\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3155572.23
msgid  "Small gap"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3147056.24
msgid  "\<ahelp hid=\"HID_SMA_SBLANK\"\>Inserts a small gap between a placeholder and the next element.\</ahelp\> You can also type \<emph\>`\</emph\> directly in the Commands window. The command must appear to the left or right of a symbol, variable, number or complete command."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN102DC
msgid  "\<image id=\"img_id3154094\" src=\"starmath/res/co21909.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154094\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3154580.5
msgid  "Align left"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3154592.6
msgid  "\<ahelp hid=\"HID_SMA_ALIGNLX\"\>This icon assigns left-alignment to \"a\" and inserts a placeholder.\</ahelp\> You can type \<emph\>alignl<?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN10317
msgid  "\<image id=\"img_id3156130\" src=\"starmath/res/co21910.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3156130\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3154723.9
msgid  "Align to horizontal center"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3149319.10
msgid  "\<ahelp hid=\"HID_SMA_ALIGNCX\"\>Assigns horizontal central alignment to \"a\" and inserts a placeholder.\</ahelp\> You can also type \<emph\>alignc<?>\</emph\> directly in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN10352
msgid  "\<image id=\"img_id3155583\" src=\"starmath/res/co21911.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155583\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3149768.7
msgid  "Align right"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3149780.8
msgid  "\<ahelp hid=\"HID_SMA_ALIGNRX\"\>Inserts the command for right alignment and a placeholder.\</ahelp\> You can also type \<emph\>alignr<?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN1038D
msgid  "\<image id=\"img_id3155085\" src=\"starmath/res/co21907.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155085\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3154338.25
msgid  "Matrix stack"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3146941.26
msgid  "\<ahelp hid=\"HID_SMA_MATRIX\"\>This icon inserts a matrix with four placeholders.\</ahelp\> You can also type \<emph\>matrix{<?>#<?>##<?>#<?>}\</emph\> directly in the \<emph\>Commands\</emph\> window. The position of an element inside this diagram is indicated by two coordinates; the first specifies the line number and the second the column number. You can expand this matrix in any direction in the \<emph\>Commands\</emph\> window by adding characters."
msgstr ""

#: text/smath/01/03090700.xhp#par_idN103C9
msgid  "\<image id=\"img_id3150027\" src=\"starmath/res/co21903.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150027\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3149358.21
msgid  "Gap"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3149370.22
msgid  "\<ahelp hid=\"HID_SMA_BLANK\"\>This icon inserts a gap or space between placeholders.\</ahelp\> You can also type \<emph\>~\</emph\> directly in the \<emph\>Commands\</emph\> window. The command must appear to the left or right of a symbol, variable, number or complete command."
msgstr ""

#: text/smath/01/03090700.xhp#par_id3155394.48
msgid  "For alignment, the \<emph\>alignl, alignc\</emph\> and \<emph\>alignr\</emph\> commands are especially effective, if you are "
msgstr ""

#: text/smath/01/03090700.xhp#par_id3151009.49
msgid  "aligning numerators and denominators, for example \<emph\>{alignl a}over{b+c}\</emph\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3148812.50
msgid  "constructing binomials or stacks, for example \<emph\>binom{2*n}{alignr k}\</emph\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3154360.51
msgid  "aligning the elements in a matrix, for example \<emph\>matrix{alignr a#b+2##c+1/3#alignl d}\</emph\> and"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3155946.52
msgid  "beginning a new line, for example \<emph\>a+b-c newline alignr x/y\</emph\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3154621.53
msgid  "When using the align instructions, note that"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3147382.54
msgid  "they can only placed at the beginning of expressions and can only occur once. Therefore you can type \<emph\>a+b alignr c\</emph\>, but not \<emph\>a+alignr b\</emph\>"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3154004.55
msgid  "they affect each other, which means that typing \<emph\>{alignl{alignr a}}over{b+c}\</emph\> aligns \<emph\>a\</emph\> on the right."
msgstr ""

#: text/smath/01/03090700.xhp#hd_id8036133
msgid  "To align using the \"matrix\" command"
msgstr ""

#: text/smath/01/03090700.xhp#par_idN10F70
msgid  "Aligning to the left"
msgstr ""

#: text/smath/01/03090700.xhp#par_id3149645.56
msgid  "If a line or an expression begins with text, it is aligned on the left by default. You can change this with any of the \<emph\>align\</emph\> commands. An example is \<emph\>stack{a+b-c*d#alignr \"text\"}\</emph\>, where \"text\" appears aligned to the right. Note that text must always be surrounded by quotation marks."
msgstr ""

#: text/smath/01/03090700.xhp#par_id3149966.57
msgid  "The standard centralized formulas can be aligned to the left without using the \<emph\>Format - Alignment\</emph\> menu. To do this, place an empty character string, that is, the inverted commas which surround any text \"\", before the section of formula that you want to align. For example, typing \<emph\>\"\" a+b newline \"\" c+d\</emph\> results in both equations being left-aligned instead of centered."
msgstr ""

#: text/smath/01/03090700.xhp#par_id3145654.46
msgid  "When typing information in the Commands window, note that some formats require spaces for the correct structure. This is especially true when entering values (for example, a lsup{3}) instead of placeholders."
msgstr ""

#: text/smath/01/03090700.xhp#par_id3148708.47
msgid  "Click \<link href=\"text/smath/01/03091100.xhp\" name=\"Brackets and Grouping\"\>Brackets and Grouping\</link\> for more information about formatting in \<emph\>$[officename] Math\</emph\>."
msgstr ""

#: text/smath/01/03090700.xhp#par_id3155340.31
msgid  "Useful information about \<link href=\"text/smath/01/03091200.xhp\" name=\"Indexes and Exponents\"\>Indexes and Exponents\</link\> and \<link href=\"text/smath/01/03091400.xhp\" name=\"Scaling\"\>Scaling\</link\>, helps you organize your document in the best possible way."
msgstr ""

#: text/smath/01/03090800.xhp#tit
msgid  "Set Operations"
msgstr ""

#: text/smath/01/03090800.xhp#bm_id3156318
msgid  "\<bookmark_value\>set operations in $[officename]Math\</bookmark_value\>\<bookmark_value\>sets of numbers\</bookmark_value\>\<bookmark_value\>included in set operator\</bookmark_value\>\<bookmark_value\>not included in set operator\</bookmark_value\>\<bookmark_value\>owns command\</bookmark_value\>\<bookmark_value\>includes set operator\</bookmark_value\>\<bookmark_value\>empty set\</bookmark_value\>\<bookmark_value\>intersection of sets\</bookmark_value\>\<bookmark_value\>union of sets\</bookmark_value\>\<bookmark_value\>difference set operator\</bookmark_value\>\<bookmark_value\>quotient set\</bookmark_value\>\<bookmark_value\>cardinal numbers\</bookmark_value\>\<bookmark_value\>subset set operators\</bookmark_value\>\<bookmark_value\>superset set operators\</bookmark_value\>\<bookmark_value\>not subset set operators\</bookmark_value\>\<bookmark_value\>not superset set operators\</bookmark_value\>\<bookmark_value\>natural numbers\</bookmark_value\>\<bookmark_value\>whole numbers\</bookmark_value\>\<bookmark_value\>real numbers\</bookmark_value\>\<bookmark_value\>complex numbers; set\</bookmark_value\>\<bookmark_value\>rational numbers\</bookmark_value\>"
msgstr ""

#: text/smath/01/03090800.xhp#hd_id3156318.1
msgid  "\<link href=\"text/smath/01/03090800.xhp\" name=\"Set Operations\"\>Set Operations\</link\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3154641.2
msgid  "\<ahelp hid=\"HID_SMA_SETOPERATIONS_CAT\"\>Assign different set operators to the characters in your \<emph\>$[officename] Math\</emph\> formula. The individual operators are shown in the lower section of the Elements window\</ahelp\>. Call the \<link href=\"text/shared/00/00000001.xhp#kontextmenue\" name=\"context menu\"\>context menu\</link\> in the \<emph\>Commands\</emph\> window to see an identical list of the individual functions. Any operators not found in the Elements window have to be entered directly in the Commands window. You can also directly insert other parts of the formula even if symbols already exist for them."
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149290.3
msgid  "After clicking the \<emph\>Set Operations\</emph\> icon in the Elements window additional icons will be shown in the lower part of this window. Simply click a symbol to incorporate the operator in the formula being edited in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#hd_id3147258.4
msgid  "The set operations in detail:"
msgstr ""

#: text/smath/01/03090800.xhp#par_idN10081
msgid  "\<image id=\"img_id3145418\" src=\"starmath/res/op21401.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3145418\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3154275.33
msgid  "is included in"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3150706.34
msgid  "\<ahelp hid=\"HID_SMA_XINY\"\>Use the icon to insert the \<emph\>is included in\</emph\> set operator with two placeholders.\</ahelp\> You can also enter \<emph\><?> in <?>\</emph\> directly into the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN100BC
msgid  "\<image id=\"img_id3153782\" src=\"starmath/res/op21402.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3153782\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3150984.35
msgid  "is not included in"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3150997.36
msgid  "\<ahelp hid=\"HID_SMA_XNOTINY\"\>Use this icon to insert the \<emph\>is not included in\</emph\> set operator with two placeholders.\</ahelp\> You can also enter \<emph\><?> notin <?> \</emph\>in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN100F7
msgid  "\<image id=\"img_id3150972\" src=\"starmath/res/op21403.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3150972\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149688.53
msgid  "includes"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149338.52
msgid  "\<ahelp hid=\"HID_SMA_XOWNSY\"\>Use this icon to insert the set operator \<emph\>includes \</emph\>with two placeholders.\</ahelp\> You can also enter \<emph\><?> owns <?>\</emph\> or \<emph\><?> ni <?>\</emph\> directly in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN10135
msgid  "\<image id=\"img_id3155180\" src=\"starmath/res/op22002.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3155180\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149101.75
msgid  "empty set"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3154829.74
msgid  "\<ahelp hid=\"HID_SMA_EMPTYSET\"\>Use this icon to insert an \<emph\>empty set\</emph\>.\</ahelp\> Enter \<emph\>emptyset\</emph\> in the Commands window, in order to insert an empty set into your document."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN1016E
msgid  "\<image id=\"img_id3147093\" src=\"starmath/res/op21405.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3147093\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149035.55
msgid  "Intersection"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3147573.54
msgid  "\<ahelp hid=\"HID_SMA_XINTERSECTIONY\"\>Use this icon to insert two placeholders with the set operator \<emph\>intersection of sets \</emph\>.\</ahelp\> The same happens if you enter \<emph\><?> intersection <?>\</emph\> Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN101A7
msgid  "\<image id=\"img_id3155147\" src=\"starmath/res/op21406.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3155147\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3147130.57
msgid  "Union"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3154376.56
msgid  "\<ahelp hid=\"HID_SMA_XUNIONY\"\>Use this icon to insert the \<emph\>union\</emph\> set operator with two placeholders.\</ahelp\> You can also enter \<emph\><?> union <?> \</emph\>directly in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN101E0
msgid  "\<image id=\"img_id3154922\" src=\"starmath/res/op21407.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3154922\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3145774.59
msgid  "Difference"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3145786.58
msgid  "\<ahelp hid=\"HID_SMA_XSETMINUSY\"\>Use this icon to insert the \<emph\>difference\</emph\> set operator.\</ahelp\> You can also enter \<emph\><?> setminus <?>\</emph\> or \<emph\><?> bslash <?>\</emph\> in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN1021C
msgid  "\<image id=\"img_id3148889\" src=\"starmath/res/op21408.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3148889\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149536.60
msgid  "Quotient set"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149549.51
msgid  "\<ahelp hid=\"HID_SMA_XSLASHY\"\>Use this icon to insert a slash for creating a \<emph\>quotient set\</emph\> with two placeholders.\</ahelp\> Enter \<emph\><?>slash<?>\</emph\> in the Commands window, to achieve the same result."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN10255
msgid  "\<image id=\"img_id3147473\" src=\"starmath/res/op22001.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3147473\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3147500.77
msgid  "aleph"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3145263.76
msgid  "\<ahelp hid=\"HID_SMA_ALEPH\"\>Use this icon to insert a \<emph\>cardinal number\</emph\>. \</ahelp\> You can achieve the same result by entering \<emph\>aleph\</emph\> in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN1028E
msgid  "\<image id=\"img_id3155974\" src=\"starmath/res/op21409.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3155974\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3150561.62
msgid  "Subset"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3156227.61
msgid  "\<ahelp hid=\"HID_SMA_XSUBSETY\"\>Use this icon to insert the \<emph\>is a subset of\</emph\> set operator.\</ahelp\> You can also enter \<emph\><?>subset<?>\</emph\> directly in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN102C9
msgid  "\<image id=\"img_id3147119\" src=\"starmath/res/op21410.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3147119\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3147448.64
msgid  "Subset or equal to"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3147460.63
msgid  "\<ahelp hid=\"HID_SMA_XSUBSETEQY\"\>Use this icon to insert the \<emph\>is a subset or equal to\</emph\> set operator with two placeholders.\</ahelp\> You can also enter \<emph\><?>subseteq<?>\</emph\> in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN10304
msgid  "\<image id=\"img_id3147065\" src=\"starmath/res/op21411.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3147065\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3154788.66
msgid  "Superset"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3151088.65
msgid  "\<ahelp hid=\"HID_SMA_XSUPSETY\"\>Use this icon to insert the set operator \<emph\>is a superset of\</emph\> and two placeholders.\</ahelp\> You can also enter \<emph\><?>supset<?>\</emph\> in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN1033F
msgid  "\<image id=\"img_id3154590\" src=\"starmath/res/op21412.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3154590\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3153305.68
msgid  "Superset or equal to"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3151119.67
msgid  "\<ahelp hid=\"HID_SMA_XSUPSETEQY\"\>Use this icon to insert the set operator \<emph\>is a super set or equal to\</emph\> with two placeholders.\</ahelp\> Alternatively, you can enter \<emph\><?>supseteq<?> \</emph\>in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN1037A
msgid  "\<image id=\"img_id3149318\" src=\"starmath/res/op21413.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3149318\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3150454.69
msgid  "not subset"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3153968.47
msgid  "\<ahelp hid=\"HID_SMA_XNSUBSETY\"\>Use this icon to insert the \<emph\>not subset\</emph\> set operator with two placeholders.\</ahelp\> Instead of this, you can also enter \<emph\><?>nsubset<?>\</emph\>."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN103B7
msgid  "\<image id=\"img_id3151193\" src=\"starmath/res/op21414.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3151193\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149236.70
msgid  "not subset or equal to"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149249.49
msgid  "\<ahelp hid=\"HID_SMA_XNSUBSETEQY\"\>Use this icon to insert the \<emph\>not subset or equal\</emph\> set operator with two placeholders.\</ahelp\> You can also enter \<emph\><?>nsubseteq<?> \</emph\>in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN103F4
msgid  "\<image id=\"img_id3146956\" src=\"starmath/res/op21415.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3146956\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3148796.71
msgid  "not superset"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149995.48
msgid  "\<ahelp hid=\"HID_SMA_XNSUPSETY\"\>Use this icon to insert the \<emph\>not superset\</emph\> set operator with two placeholders.\</ahelp\> You can also enter \<emph\><?>nsupset<?> \</emph\>in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN10431
msgid  "\<image id=\"img_id3151223\" src=\"starmath/res/op21416.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3151223\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3155798.72
msgid  "not superset or equal to"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3155810.50
msgid  "\<ahelp hid=\"HID_SMA_XNSUPSETEQY\"\>Use this icon to insert the \<emph\>not superset or equal\</emph\> set operator with two placeholders.\</ahelp\> Instead of this you can type \<emph\><?>nsupseteq<?> \</emph\>in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN1046E
msgid  "\<image id=\"img_id3156087\" src=\"starmath/res/op21417.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3156087\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3148815.79
msgid  "Set of natural numbers"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3154352.78
msgid  "\<ahelp hid=\"HID_SMA_SETN\"\>Use this icon to insert a character for the \<emph\>set of natural numbers\</emph\>.\</ahelp\> Instead of this, you can enter \<emph\>setn\</emph\> in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN104A7
msgid  "\<image id=\"img_id3147383\" src=\"starmath/res/op21418.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3147383\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149628.81
msgid  "Set of whole numbers"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149641.80
msgid  "\<ahelp hid=\"HID_SMA_SETZ\"\>Use this icon to insert a character for the \<emph\>set of whole numbers\</emph\>.\</ahelp\> You can also do this by entering \<emph\>setz\</emph\> in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN104E0
msgid  "\<image id=\"img_id3154038\" src=\"starmath/res/op21419.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3154038\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149961.83
msgid  "Set of rational numbers"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149974.82
msgid  "\<ahelp hid=\"HID_SMA_SETQ\"\>Use this icon to insert a character for the \<emph\>set of rational numbers\</emph\>.\</ahelp\> You can also do this by directly entering \<emph\>setq\</emph\> in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN10519
msgid  "\<image id=\"img_id3149625\" src=\"starmath/res/op21420.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3149625\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3145663.85
msgid  "Set of real numbers"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3148709.84
msgid  "\<ahelp hid=\"HID_SMA_SETR\"\>Use this icon to insert a character for the \<emph\>set of real numbers\</emph\>.\</ahelp\> Instead of this, you can enter \<emph\>setr\</emph\> in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_idN10552
msgid  "\<image id=\"img_id3155555\" src=\"starmath/res/op21421.png\" width=\"8.47mm\" height=\"8.47mm\"\>\<alt id=\"alt_id3155555\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3149519.87
msgid  "Set of complex numbers"
msgstr ""

#: text/smath/01/03090800.xhp#par_id3148672.86
msgid  "\<ahelp hid=\"HID_SMA_SETC\"\>Use this icon to insert a character for the \<emph\>set of complex numbers\</emph\>.\</ahelp\> You can also enter \<emph\>setc\</emph\> in the Commands window."
msgstr ""

#: text/smath/01/03090800.xhp#par_id3154224.73
msgid  "Be sure to leave spaces (gaps) between values and commands when entering them manually in the Commands window. This ensures that the correct structure is achieved."
msgstr ""

#: text/smath/01/03090900.xhp#tit
msgid  "$[officename] Math Examples"
msgstr ""

#: text/smath/01/03090900.xhp#bm_id3151265
msgid  "\<bookmark_value\>examples;$[officename] Math formulas\</bookmark_value\>\<bookmark_value\>$[officename] Math;examples\</bookmark_value\>\<bookmark_value\>formulas;examples\</bookmark_value\>"
msgstr ""

#: text/smath/01/03090900.xhp#hd_id3151265.1
msgid  "\<variable id=\"examples\"\>\<link href=\"text/smath/01/03090900.xhp\" name=\"$[officename] Math Examples\"\>$[officename] Math Examples\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03090900.xhp#par_id3153624.2
msgid  "The following is a list of sample formulas in \<emph\>$[officename] Math\</emph\>."
msgstr ""

#: text/smath/01/03090901.xhp#tit
msgid  "Symbols with Indices"
msgstr ""

#: text/smath/01/03090901.xhp#hd_id3156382.1
msgid  "\<link href=\"text/smath/01/03090901.xhp\" name=\"Symbols with Indices\"\>Symbols with Indices\</link\>"
msgstr ""

#: text/smath/01/03090901.xhp#par_id3150301.2
msgid  "The following example explains how to create symbols with indexes in \<emph\>$[officename] Math\</emph\>. You can copy this example to the \<emph\>Commands\</emph\> window by using the clipboard and use it in your own formula."
msgstr ""

#: text/smath/01/03090901.xhp#par_id3153818
msgid  "\<image id=\"img_id3148870\" src=\"res/helpimg/smzb1.png\" width=\"3.217cm\" height=\"2.939cm\"\>\<alt id=\"alt_id3148870\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090902.xhp#tit
msgid  "Symbols with Indices"
msgstr ""

#: text/smath/01/03090902.xhp#hd_id3155959.1
msgid  "\<link href=\"text/smath/01/03090902.xhp\" name=\"Symbols with Indices\"\>Symbols with Indices\</link\>"
msgstr ""

#: text/smath/01/03090902.xhp#par_id3150300.2
msgid  "Here is another example of creating symbols with indexes in \<emph\>$[officename] Math\</emph\>. You can copy this example to the \<emph\>Commands\</emph\> window using the clipboard and use it in your own formula."
msgstr ""

#: text/smath/01/03090902.xhp#par_id3153912
msgid  "\<image id=\"img_id3149126\" src=\"res/helpimg/smzb2.png\" width=\"3.387cm\" height=\"2.882cm\"\>\<alt id=\"alt_id3149126\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090902.xhp#par_id3154766.4
msgid  "%SIGMA_g^{{}+{}}lsup 3"
msgstr ""

#: text/smath/01/03090903.xhp#tit
msgid  "Symbols with Indices"
msgstr ""

#: text/smath/01/03090903.xhp#hd_id3155959.1
msgid  "\<link href=\"text/smath/01/03090903.xhp\" name=\"Symbols with Indices\"\>Symbols with Indices\</link\>"
msgstr ""

#: text/smath/01/03090903.xhp#par_id3150300.2
msgid  "A third example of how to use \<emph\>$[officename] Math\</emph\> to create symbols with indexes is shown below. You can copy the example into the clipboard and use it in your own formula in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03090903.xhp#par_id3148866
msgid  "\<image id=\"img_id3153246\" src=\"res/helpimg/smzb3.png\" width=\"5.673cm\" height=\"2.997cm\"\>\<alt id=\"alt_id3153246\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090903.xhp#par_id3153808.4
msgid  "%PHI^{i_1 i_2 dotsaxis i_n}_{k_1 k_2 dotsaxis k_n}"
msgstr ""

#: text/smath/01/03090904.xhp#tit
msgid  "Matrix with Varying Font Sizes"
msgstr ""

#: text/smath/01/03090904.xhp#hd_id3155960.1
msgid  "\<link href=\"text/smath/01/03090904.xhp\" name=\"Matrix with Varying Font Sizes\"\>Matrix with Varying Font Sizes\</link\>"
msgstr ""

#: text/smath/01/03090904.xhp#par_id3154656.2
msgid  "Here is an example of how to create a matrix with varying font sizes in \<emph\>$[officename] Math\</emph\>. You can copy this example to the \<emph\>Commands\</emph\> window using the clipboard and use it in your own formula."
msgstr ""

#: text/smath/01/03090904.xhp#par_id3153915
msgid  "\<image id=\"img_id3150213\" src=\"res/helpimg/smzb5.png\" width=\"16.51cm\" height=\"4.971cm\"\>\<alt id=\"alt_id3150213\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090904.xhp#par_id3146965.4
msgid  "func G^{(%alpha\" ,\" %beta)}_{ x_m x_n} = left[ matrix { arctan(%alpha) # arctan(%beta) ## x_m + x_n # x_m - x_n }right]"
msgstr ""

#: text/smath/01/03090905.xhp#tit
msgid  "Matrix"
msgstr ""

#: text/smath/01/03090905.xhp#hd_id3154702.1
msgid  "\<link href=\"text/smath/01/03090905.xhp\" name=\"Matrix\"\>Matrix\</link\>"
msgstr ""

#: text/smath/01/03090905.xhp#par_id3150344.2
msgid  "Here is an example of how to create a matrix with \<emph\>$[officename] Math\</emph\>. If you want to use the example in your own formula, you can copy it to the \<emph\>Commands\</emph\> window using the clipboard."
msgstr ""

#: text/smath/01/03090905.xhp#par_id3153912
msgid  "\<image id=\"img_id3149126\" src=\"res/helpimg/smzb4.png\" width=\"10.839cm\" height=\"6.479cm\"\>\<alt id=\"alt_id3149126\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090906.xhp#tit
msgid  "Matrix in Bold Font"
msgstr ""

#: text/smath/01/03090906.xhp#hd_id3154704.1
msgid  "\<link href=\"text/smath/01/03090906.xhp\" name=\"Matrix in Bold Font\"\>Matrix in Bold Font\</link\>"
msgstr ""

#: text/smath/01/03090906.xhp#par_id3150342.2
msgid  "Here is an example of how to create a bold font matrix in \<emph\>$[officename] Math\</emph\>. You can copy this example to the \<emph\>Commands\</emph\> window using the clipboard and use it in your own formula."
msgstr ""

#: text/smath/01/03090906.xhp#par_id3148866
msgid  "\<image id=\"img_id3150210\" src=\"res/helpimg/smzb6.png\" width=\"9.511cm\" height=\"7.99cm\"\>\<alt id=\"alt_id3150210\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090906.xhp#par_id3154763.4
msgid  "bold { f(x\", \"y) = left [ stack { x + y over z + left lbrace matrix { 2 # 3 # 4 ## 4 # 5 # 6 ## 6 # 7 # 8} right rbrace # {y + sin (x)} over %alpha # z + y over g } right ]}"
msgstr ""

#: text/smath/01/03090907.xhp#tit
msgid  "Functions"
msgstr ""

#: text/smath/01/03090907.xhp#hd_id3155961.1
msgid  "\<link href=\"text/smath/01/03090907.xhp\" name=\"Functions\"\>Functions\</link\>"
msgstr ""

#: text/smath/01/03090907.xhp#par_id3148489.2
msgid  "Here is an example of how to create functions with \<emph\>$[officename] Math\</emph\>. If you want to use the example in your own formula, copy it to the \<emph\>Commands\</emph\> window using the clipboard."
msgstr ""

#: text/smath/01/03090907.xhp#par_id3153912
msgid  "\<image id=\"img_id3148871\" src=\"res/helpimg/smzb7.png\" width=\"7.987cm\" height=\"2.768cm\"\>\<alt id=\"alt_id3148871\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090908.xhp#tit
msgid  "Square Root"
msgstr ""

#: text/smath/01/03090908.xhp#hd_id3154704.1
msgid  "\<link href=\"text/smath/01/03090908.xhp\" name=\"Square Root\"\>Square Root\</link\>"
msgstr ""

#: text/smath/01/03090908.xhp#par_id3145790.2
msgid  "Here is an example of how to create a square root with \<emph\>$[officename] Math\</emph\>. If you want to use the example in your own formula, copy it to the \<emph\>Commands\</emph\> window using the clipboard."
msgstr ""

#: text/smath/01/03090908.xhp#par_id3148870
msgid  "\<image id=\"img_id3153917\" src=\"res/helpimg/smzb8.png\" width=\"9.567cm\" height=\"3.597cm\"\>\<alt id=\"alt_id3153917\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090908.xhp#par_id3153914.4
msgid  "%LAMBDA_{deg\",\"t}=1 + %alpha_deg SQRT {M_t over M_{(t=0)}-1}~\".\""
msgstr ""

#: text/smath/01/03090909.xhp#tit
msgid  "Fonts and Font Sizes"
msgstr ""

#: text/smath/01/03090909.xhp#bm_id7562181
msgid  "\<bookmark_value\>font sizes;example\</bookmark_value\>\<bookmark_value\>sum range example\</bookmark_value\>\<bookmark_value\>examples ;integral\</bookmark_value\>\<bookmark_value\>range of integral example\</bookmark_value\>\<bookmark_value\>integrals;example\</bookmark_value\>"
msgstr ""

#: text/smath/01/03090909.xhp#hd_id3155959.1
msgid  "\<link href=\"text/smath/01/03090909.xhp\" name=\"Fonts and Font Sizes\"\>Integral and Sum Ranges, Font Size\</link\>"
msgstr ""

#: text/smath/01/03090909.xhp#par_id3145791.2
msgid  "Here is an example of how to use various fonts and font sizes within a formula in \<emph\>$[officename] Math\</emph\>."
msgstr ""

#: text/smath/01/03090909.xhp#par_id3151243
msgid  "\<image id=\"img_id3148871\" src=\"res/helpimg/smzb9.png\" width=\"9.257cm\" height=\"3.196cm\"\>\<alt id=\"alt_id3148871\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090910.xhp#tit
msgid  "Attributes"
msgstr ""

#: text/smath/01/03090910.xhp#hd_id3154702.1
msgid  "\<link href=\"text/smath/01/03090910.xhp\" name=\"Attributes\"\>Attributes\</link\>"
msgstr ""

#: text/smath/01/03090910.xhp#par_id3150301.2
msgid  "This section contains an example of how you can use different attributes in a formula in \<emph\>$[officename] Math\</emph\>."
msgstr ""

#: text/smath/01/03090910.xhp#par_id3148703
msgid  "\<image id=\"img_id3151242\" src=\"res/helpimg/smzb10.png\" width=\"8.975cm\" height=\"2.198cm\"\>\<alt id=\"alt_id3151242\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03090910.xhp#par_id3150048.4
msgid  "%rho(font sans bold q\",\"%omega) = int func e^{i %omega t}%rho(font sans bold q\",\"t)\"d\"t"
msgstr ""

#: text/smath/01/03091100.xhp#tit
msgid  "Brackets and Grouping"
msgstr ""

#: text/smath/01/03091100.xhp#bm_id3147341
msgid  "\<bookmark_value\>brackets and grouping in $[officename] Math\</bookmark_value\>\<bookmark_value\>grouping and brackets in $[officename] Math\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091100.xhp#hd_id3147341.1
msgid  "\<link href=\"text/smath/01/03091100.xhp\" name=\"Brackets and Grouping\"\>Brackets and Grouping\</link\>"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3150342.2
msgid  "Note: the quotation marks in the examples are used to emphasize text and do not belong to the content of the formulas and commands."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3146962.3
msgid  "When typing example formulas into the \<emph\>Commands\</emph\> window, note that spaces are often required for correct structure."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3149054.4
msgid  "Braces \"{}\" are used to group expressions together to form one new expression. For example, \"sqrt {x * y}\" is the square root of the entire product x*y, while \"sqrt x * y\" is the square root of x multiplied by y. Braces do not require an extra space."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3151392.5
msgid  "Set brackets were previously inserted in the Elements window or directly in the Commands window as \"left lbrace <?> right rbrace\". Now, a left and a right set bracket can also be inserted using \"lbrace\" and \"rbrace\", with or without wildcards."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3147403.6
msgid  "There are a total of eight (8) different types of brackets available. The \"ceil\" and \"floor\" brackets are often used for rounding up or down the argument to the next integer: \"lceil -3.7 rceil = -3\" or \"lfloor -3.7 rfloor = -4\"."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3146320.63
msgid  "Operator brackets, also known as Bra-kets (angle brackets with a vertical line in between), are common in Physics notation: \"langle a mline b rangle\" or \"langle a mline b mline c over d mline e rangle.\" The height and positioning of the vertical lines always corresponds exactly to the enclosing brackets."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3157870.7
msgid  "All brackets may only be used in pairs. The brackets have some common characteristics:"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3155761.8
msgid  "All types of brackets have the same grouping function as described for \"{}\" brackets."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3145590.9
msgid  "All types of brackets, including those that are visible, permit empty group definition. The enclosed expression may therefore be empty."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3154562.10
msgid  "Brackets do not adjust their size to the enclosed expression. For example, if you want \"( a over b )\" with a bracket size adjusted to a and b you must insert \"left\" and \"right\". Entering \"left(a over b right)\" produces appropriate sizing. If, however, the brackets themselves are part of the expression whose size is changed, they are included the size change: \"size 3(a over b)\" and \"size 12(a over b)\". The sizing of the bracket-to-expression ratio does not change in any way."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3153002.11
msgid  "Since \"left\" and \"right\" ensure unique assignment of the brackets, every single bracket can be used as an argument for these two commands, even placing right brackets on the left side, or left brackets on the right. Instead of a bracket you can use the \"none\" qualifier, which means that there is no bracket shown and that there is no space reserved for a bracket. Using this, you can create the following expressions:"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3150014.12
msgid  "left lbrace x right none"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3149877.13
msgid  "left [ x right )"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3145241.14
msgid  "left ] x right ["
msgstr ""

#: text/smath/01/03091100.xhp#par_id3156060.15
msgid  "left rangle x right lfloor"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3150935.16
msgid  "The same rules apply to \"left\" and \"right\" as to the other brackets: they also work as group builders and may enclose empty expressions."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3149030.17
msgid  "The combination of mismatched brackets, single brackets and repositioned left and right brackets occurs often in mathematical formulas. The following is a formula that will create an error when typed:"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3155989.19
msgid  "[2, 3) - right open interval"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3147169.23
msgid  "Using \"left\" and \"right\" makes the above expression valid in $[officename] Math: \"left [2, 3 right )\". However, the brackets do not have any fixed size because they adjust to the argument. Setting a single bracket is a bit cumbersome. Therefore, there you can display single brackets with a fixed size by placing a \"\\\\\" (backslash) in front of normal brackets. These brackets then act like any other symbol and no longer have the special functionality of brackets; that is they do not work as group builders and their orientation corresponds to that of other symbols. See \"size *2 \\\\langle x \\\\rangle\" and \"size *2 langle x rangle\"."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3153720.24
msgid  "The complete overview is as follows"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3149715.25
msgid  "\\\\{ or \\\\lbrace, \\\\} or \\\\rbrace"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3150756.26
msgid  "\\\\(, \\\\)"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3145207.27
msgid  "\\\\[, \\\\]"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3153153.28
msgid  "\\\\langle, \\\\rangle"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3150263.29
msgid  "\\\\lceil, \\\\rceil"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3147252.30
msgid  "\\\\lfloor, \\\\rfloor"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3154690.31
msgid  "\\\\lline, \\\\rline"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3145414.32
msgid  "\\\\ldline, \\\\rdline"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3147514.33
msgid  "In this way, intervals like the one above can be built in \<emph\>$[officename] Math\</emph\> without any problems: \\\\[2\", \"3\\\\) or \"\\\\]2\", \"3\\\\[ (Attention: These quotation marks are part of the entry.)"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3153532.34
msgid  "Please note that the quotation marks must be entered and can be obtained with \<emph\>Shift+2\</emph\> and not with typographical quotation marks. Generally, punctuation marks (like the comma in this case) are set as text. Although it is also possible to type \"\\\\[2,~3\\\\)\" the above option is preferable. In the previous example, \"fixed size\" always describes a bracket size dependent on the font size used."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3153674.35
msgid  "Nesting groups within each other is relatively problem-free. In the formula hat \"{a + b}\" the \"hat\" is displayed simply over the center of \"{a + b}\". Also, \"color red lceil a rceil\" and \"grave hat langle x * y rangle\" work as expected. The result of the latter can be compared to \"grave {hat langle x * y rangle}.\" These attributes do not compete, but rather can be combined."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3147526.36
msgid  "This differs slightly for competing or mutually influencing attributes. This is often the case with font attributes. For example, which color does the b have in \"color yellow color red (a + color green b)\", or which size does it have in \"size *4 (a + size /2 b)\"? Given a base size of 12, does it have the size 48, 6 or even 24 (which could be seen as a combination)? The following are basic resolution rules, which will be followed consistently in the future. In general, the rules apply to all group operations. This only has a visible effect on the font attributes, like \"bold\", \"ital\", \"phantom\", \"size\", \"color\" and \"font\":"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3152952.37
msgid  "Group operations in sequence are treated as if every single operation is enclosed by braces. They are nested, and in every level there can be no more than one operation. Here is an example of a formula with many group operations: \"size 12 color red font sans size -5 (a + size 8 b)\" like \"{size 12{color red{font sans{size -5 (a + {size 8 b})}}}}\"."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3158441.38
msgid  "This example formula is then interpreted from left to right. The operations only affect its corresponding group (or expression). Operations further to the right \"replace\" or \"combine themselves with\" their predecessors."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3150994.39
msgid  "A group operation does not have any effect on higher-level operations but rather affects only lower-level groups and expressions, including their brackets and super-/subscripts. For example, \"a + size *2 (b * size -8 c_1)^2\""
msgstr ""

#: text/smath/01/03091100.xhp#par_id3154196.40
msgid  "\"color ...\" and \"font ...\" as well as \"size n\" (n is a decimal) replace any preceding operations of the same type"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3154136.41
msgid  "for \"size +n\", \"size -n\", \"size *n\", and \"size /n\" the effects of the operations are combined,"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3146934.42
msgid  "\"size *2 size -5 a\" would be double the starting size minus 5"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3149297.43
msgid  "\"font sans ( a + font serif b)\""
msgstr ""

#: text/smath/01/03091100.xhp#par_id3155174.44
msgid  "\"size *2 ( a + size /2 b )\""
msgstr ""

#: text/smath/01/03091100.xhp#par_id3154906.50
msgid  "To change the size of a formula, use \"size +\" or -,*,/. Do not use \"size n\". These can easily be used in any context. This enables you to copy to other areas by using Copy and Paste, and the result remains the same. Furthermore, such expressions survive a change of base size in the menu better than when using \"size n\". If you use only \"size *\" and \"size /\" (for example, \"size *1.24 a or size /0.86 a\") the proportions remain intact."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3147587.51
msgid  "Examples (with a base size of 12 and 50% for indexes):"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3148734.52
msgid  "Exactly identical proportions with \"size 18 a_n\" and \"size *1.5 a_n\"."
msgstr ""

#: text/smath/01/03091100.xhp#par_id3152766.53
msgid  "This differs in different contexts: \"x^{size 18 a_n}\" and \"x^{size *1.5 a_n}\""
msgstr ""

#: text/smath/01/03091100.xhp#par_id3157986.54
msgid  "Examples with size +n for a comparison. They look identical:"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3158001.55
msgid  "a_{size 8 n}"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3147332.56
msgid  "a_{size +2 n}"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3155143.57
msgid  "a_{size *1.333 n}"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3147129.58
msgid  "The following examples, however, do not look identical:"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3147073.59
msgid  "x^{a_{size 8 n}}"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3147086.60
msgid  "x^{a_{size +2 n}}"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3154386.61
msgid  "x^{a_{size *1.333 n}}"
msgstr ""

#: text/smath/01/03091100.xhp#par_id3153354.62
msgid  "Note that all n here have different sizes. The size 1.333 results from 8/6, the desired size divided by the default index size 6. (Index size 50% with a base size of 12)"
msgstr ""

#: text/smath/01/03091200.xhp#tit
msgid  "Indexes and Exponents"
msgstr ""

#: text/smath/01/03091200.xhp#bm_id3150746
msgid  "\<bookmark_value\>indexes and exponents in $[officename] Math\</bookmark_value\>\<bookmark_value\>exponents and indexes in $[officename] Math\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091200.xhp#hd_id3150746.1
msgid  "\<link href=\"text/smath/01/03091200.xhp\" name=\"Indexes and Exponents\"\>Indexes and Exponents\</link\>"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3153730.2
msgid  "Here, you will find basic information about indexes and exponents in \<emph\>$[officename] Math\</emph\>. You can try the examples described here to help you understand the details discussed. (The quotation marks in this text are for emphasis purposes only and are not part of the examples.)"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3149884.3
msgid  "The index and exponent for a character are displayed one on top of the other, left-justified to the base character. For example, type \<emph\>a_2^3\</emph\> or \<emph\>a^3_2\</emph\>. This can be in any order. Instead of \<emph\>'_'\</emph\> and \<emph\>'^'\</emph\>, you can use \<emph\>'sub'\</emph\> and \<emph\>'sup'\</emph\>."
msgstr ""

#: text/smath/01/03091200.xhp#par_id3148387.4
msgid  "However, it is no longer possible to use the following patterns"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3149029.5
msgid  "a_2_3"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3155985.6
msgid  "a^2^3"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3153923.7
msgid  "a_2^3_4"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3153724.8
msgid  "Each sub-/superscript position of a base character can only be used once. You must use brackets to indicate the desired result. The following examples illustrate this"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3151185.9
msgid  "a_{2_3}"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3151272.10
msgid  "a^{2^3}"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3156316.11
msgid  "a_2^{3_4}"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3145207.12
msgid  "a_{2^3}^{4_5}"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3151173.13
msgid  "Unlike other formula editors where \"\<emph\>_\</emph\>\" and \" \<emph\>^\</emph\> \" only refer to the next character (\"a_24\" refers only to the \"2\"), $[officename] Math refers to the entire number(s)/name(s)/text. If you want to put superscripts and subscripts in sequence, the expression can be written as follows: a_2{}^3 or a^3{}_2"
msgstr ""

#: text/smath/01/03091200.xhp#par_id3154260.15
msgid  "To write tensors, \<emph\>$[officename] Math\</emph\> provides several options. In addition to the notation \"R_i{}^{jk}{}_l\", common in other applications, additional notations can be used, namely \"R_i{}^jk{}_l\" and \"{{R_i}^jk}_l.\""
msgstr ""

#: text/smath/01/03091200.xhp#par_id3147516.16
msgid  "Super- and subscripts to the left of the base character can also be right-justified. To do this, the new commands \"lsub\" and \"lsup\" are used. Both commands have the same effect as \"sub\" and \"sup\", except that they are left of the base character. See also \"a lsub 2 lsup 3.\""
msgstr ""

#: text/smath/01/03091200.xhp#par_id3154276.17
msgid  "The rules governing unambiguity and the necessity of using brackets remain the same. In principle, this can be achieved with \<emph\>{}_2^3 a\</emph\>."
msgstr ""

#: text/smath/01/03091200.xhp#par_id3152961.18
msgid  "The commands \"sub\" and \"sup\" are also available as \"rsub\" and \"rsup\"."
msgstr ""

#: text/smath/01/03091200.xhp#par_id3158437.20
msgid  "Using the \"csub\" and \"csup\" commands, you can write super- and subscripts directly above or below a character. An example is \"a csub y csup x\". Combinations of indexes and exponents together are also possible: \"abc_1^2 lsub 3 lsup 4 csub 55555 csup 66666.\""
msgstr ""

#: text/smath/01/03091200.xhp#par_id3154570.21
msgid  "Super- and subscripts can be attached to most unary and binary operators. Two examples: \"a div_2 b a<csub n b +_2 h\" and \"a toward csub f b x toward csup f y.\""
msgstr ""

#: text/smath/01/03091200.xhp#par_id3155904.19
msgid  "Be sure to also enter all spaces between characters when entering these examples into the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03091300.xhp#tit
msgid  "Attributes"
msgstr ""

#: text/smath/01/03091300.xhp#bm_id3148839
msgid  "\<bookmark_value\>attributes; additional information\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091300.xhp#hd_id3148839.1
msgid  "\<link href=\"text/smath/01/03091300.xhp\" name=\"Attributes\"\>Attributes\</link\>"
msgstr ""

#: text/smath/01/03091300.xhp#par_id3150051.2
msgid  "Additional information about attributes in \<emph\>$[officename] Math\</emph\> is found here."
msgstr ""

#: text/smath/01/03091300.xhp#par_id3146966.3
msgid  "The \<emph\>acute\</emph\>, \<emph\>bar\</emph\>, \<emph\>breve\</emph\>, \<emph\>check\</emph\>, \<emph\>circle\</emph\>, \<emph\>dot\</emph\>, \<emph\>ddot\</emph\>, \<emph\>dddot\</emph\>, \<emph\>grave\</emph\>, \<emph\>hat\</emph\>, \<emph\>tilde\</emph\> and \<emph\>vec\</emph\> attributes always have a fixed size and do not become wider (longer) if they are above a long symbol. By default, the attributes are centered."
msgstr ""

#: text/smath/01/03091300.xhp#par_id3154557.4
msgid  "The only attributes which grow with the length of the symbol are \<emph\>overline\</emph\>, \<emph\>underline\</emph\> and \<emph\>overstrike\</emph\>."
msgstr ""

#: text/smath/01/03091300.xhp#par_id3151180.6
msgid  "For some character strings, it is possible that a line inserted with \<emph\>underline\</emph\> is too close to the character. In this case, an empty group can solve the problem: \<emph\>underline Q sub {}\</emph\> instead of \<emph\>underline Q\</emph\>."
msgstr ""

#: text/smath/01/03091400.xhp#tit
msgid  "Scaling"
msgstr ""

#: text/smath/01/03091400.xhp#bm_id3153923
msgid  "\<bookmark_value\>scaling; in %PRODUCTNAME Math\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091400.xhp#hd_id3153923.1
msgid  " \<link href=\"text/smath/01/03091400.xhp\" name=\"Scaling\"\>Scaling\</link\>"
msgstr ""

#: text/smath/01/03091400.xhp#par_id3147173.2
msgid  "More detailed information about scaling in \<emph\>\<item type=\"productname\"\>%PRODUCTNAME\</item\> Math\</emph\> as well as some examples can be found here. (The quotation marks in this text are for emphasis purposes only and are not part of the examples.)"
msgstr ""

#: text/smath/01/03091400.xhp#par_id3156316.3
msgid  "The factorial is not scaled (example: \"fact stack{a#b}\" and \"fact {a over b}\") but is oriented using the baseline or center of the arguments."
msgstr ""

#: text/smath/01/03091400.xhp#par_id3150756.4
msgid  "Brackets always have a fixed size as well. This applies to all symbols that can be used as brackets. Compare \"(((a)))\", \"( stack{a#b#c})\", \"(a over b).\""
msgstr ""

#: text/smath/01/03091400.xhp#par_id3147570.7
msgid  "Brackets preceded by \"left\" or \"right\", however, are always adjusted to the argument. See \"left(left(left(a right)right)right)\", \"left(stack{a#b#c}right)\", \"left(a over b right).\""
msgstr ""

#: text/smath/01/03091400.xhp#par_id3145206.11
msgid  "Some \<link href=\"text/smath/01/03091300.xhp\" name=\"Attributes\"\>Attributes\</link\> have fixed sizes; do not change these if they are placed above a long symbol."
msgstr ""

#: text/smath/01/03091400.xhp#par_id3154694.12
msgid  "The spaces in the examples are required for the correct structure. You may not delete them when making entries in the Commands window."
msgstr ""

#: text/smath/01/03091500.xhp#tit
msgid  "Formula Reference Tables"
msgstr ""

#: text/smath/01/03091500.xhp#bm_id3155961
msgid  "\<bookmark_value\>$[officename] Math;reference list\</bookmark_value\>\<bookmark_value\>formulas;reference tables\</bookmark_value\>\<bookmark_value\>reference tables; formulas\</bookmark_value\>\<bookmark_value\>operators;in Math\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091500.xhp#hd_id3155961.1
msgid  "\<variable id=\"reference\"\>\<link href=\"text/smath/01/03091500.xhp\" name=\"Formula Reference Tables\"\>Formula Reference Tables\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03091500.xhp#par_id3149502.350
msgid  "\<variable id=\"ref\"\>This reference section contains lists of many operators, functions, symbols and formatting features available in \<emph\>$[officename] Math\</emph\>. Many of the commands displayed can be inserted using the icons in the \<emph\>Elements\</emph\> window or the context menu of the \<emph\>Commands\</emph\> window.\</variable\>"
msgstr ""

#: text/smath/01/03091501.xhp#tit
msgid  "Unary and Binary Operators"
msgstr ""

#: text/smath/01/03091501.xhp#bm_id3149126
msgid  "\<bookmark_value\>unary operators; list of\</bookmark_value\>\<bookmark_value\>binary operators; list of\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091501.xhp#hd_id2897122
msgid  "\<variable id=\"unary\"\>\<link href=\"text/smath/01/03091501.xhp\" name=\"Unary and Binary Operators\"\>Unary and Binary Operators\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_idN106F7
msgid  "Typed command(s)"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3151388.472
msgid  "Symbol in Elements Window"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3155764.474
msgid  "Meaning"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3156276
msgid  "\<image id=\"Graphic10\" src=\"starmath/res/un21209.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3155125.38
msgid  "Subtraction"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3163824
msgid  "\<image id=\"Graphic21\" src=\"starmath/res/un21202.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3151266.8
msgid  "- Sign"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3147514
msgid  "\<image id=\"Graphic4\" src=\"starmath/res/un21204.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3150358.12
msgid  "Minus/Plus"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3154821
msgid  "\<image id=\"Graphic13\" src=\"starmath/res/un21212.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3147106.52
msgid  "Division"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3155179
msgid  "\<image id=\"Graphic7\" src=\"starmath/res/un21208.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3148972.42
msgid  "Multiplication"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3150832
msgid  "\<image id=\"Graphic6\" src=\"starmath/res/un21205.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3151332.34
msgid  "Addition"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3145590
msgid  "\<image id=\"Graphic2\" src=\"starmath/res/un21201.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3148390.5
msgid  "+ Sign"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3150764
msgid  "\<image id=\"Graphic3\" src=\"starmath/res/un21203.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3153579.10
msgid  "Plus/Minus"
msgstr ""

#: text/smath/01/03091501.xhp#par_idN10A6B
msgid  "\<item type=\"literal\"\>and\</item\> or \<item type=\"literal\"\>&\</item\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3146336
msgid  "\<image id=\"Graphic14\" src=\"starmath/res/un21214.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3155565.62
msgid  "Boolean AND operation"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3903317
msgid  "No symbol. Usage:"
msgstr ""

#: text/smath/01/03091501.xhp#par_id8633686
msgid  "a boper %SYM1 b"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3149632.136
msgid  "Binary operator. A user-defined symbol follows, which is used as a binary operator."
msgstr ""

#: text/smath/01/03091501.xhp#par_id1713309
msgid  "No symbol. Usage:"
msgstr ""

#: text/smath/01/03091501.xhp#par_id4594256
msgid  "uoper %SYM2 b"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3154624.28
msgid  "Unary operator. A user-defined symbol follows, which is a used as a unary operator."
msgstr ""

#: text/smath/01/03091501.xhp#par_id3147212
msgid  "\<image id=\"Graphic8\" src=\"starmath/res/un21206.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3155143.44
msgid  "Multiplication, small multiply symbol"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3151130
msgid  "\<image id=\"Graphic16\" src=\"starmath/res/un21221.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3156125.373
msgid  "Concatenate symbols"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3147470
msgid  "\<image id=\"Graphic12\" src=\"starmath/res/un21211.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3145129.58
msgid  "Division"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3151319
msgid  "\<image id=\"Graphic5\" src=\"starmath/res/un21213.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3147527.14
msgid  "Boolean NOT"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3959776
msgid  "No symbol."
msgstr ""

#: text/smath/01/03091501.xhp#par_id3150729.56
msgid  "Slash / in circle"
msgstr ""

#: text/smath/01/03091501.xhp#par_id1206701
msgid  "No symbol."
msgstr ""

#: text/smath/01/03091501.xhp#par_id3151227.46
msgid  "Small multiply symbol in circle"
msgstr ""

#: text/smath/01/03091501.xhp#par_id815759
msgid  "No symbol."
msgstr ""

#: text/smath/01/03091501.xhp#par_id3154841.40
msgid  "Subtract symbol in circle"
msgstr ""

#: text/smath/01/03091501.xhp#par_id7664113
msgid  "No symbol."
msgstr ""

#: text/smath/01/03091501.xhp#par_id3148783.36
msgid  "Add symbol in circle"
msgstr ""

#: text/smath/01/03091501.xhp#par_idN10AB0
msgid  "\<item type=\"literal\"\>or\</item\> or \<item type=\"literal\"\>|\</item\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3147065
msgid  "\<image id=\"Graphic15\" src=\"starmath/res/un21215.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3153797.64
msgid  "Boolean OR operation"
msgstr ""

#: text/smath/01/03091501.xhp#par_id7552110
msgid  "No symbol."
msgstr ""

#: text/smath/01/03091501.xhp#par_id3155380.50
msgid  "Multiply symbol times in circle"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3148873
msgid  "\<image id=\"Graphic11\" src=\"starmath/res/un21210.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3150118.60
msgid  "Division/Fraction"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3147073
msgid  "\<image id=\"Graphic9\" src=\"starmath/res/un21207.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091501.xhp#par_id3151024.48
msgid  "Multiplication"
msgstr ""

#: text/smath/01/03091501.xhp#par_id4930875
msgid  "No symbol."
msgstr ""

#: text/smath/01/03091501.xhp#par_id3149241.415
msgid  "Backslash \\\\ between two characters, of which the right is superscript, the left subscript"
msgstr ""

#: text/smath/01/03091501.xhp#par_id4568620
msgid  "No symbol."
msgstr ""

#: text/smath/01/03091501.xhp#par_id3155587.413
msgid  "Slash / between two characters, of which the left is superscript, the right subscript"
msgstr ""

#: text/smath/01/03091502.xhp#tit
msgid  "Relations"
msgstr ""

#: text/smath/01/03091502.xhp#bm_id3149650
msgid  "\<bookmark_value\>relations operators;list of\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091502.xhp#hd_id2083193
msgid  "\<variable id=\"relations\"\>\<link href=\"text/smath/01/03091502.xhp\" name=\"Relations\"\>Relations\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_idN10C98
msgid  "Typed command(s)"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3154032.475
msgid  "Symbol in Elements Window"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3147272.477
msgid  "Meaning"
msgstr ""

#: text/smath/01/03091502.xhp#par_idN10E08
msgid  "\<item type=\"literal\"\><\</item\> or \<item type=\"literal\"\>lt\</item\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3156247
msgid  "\<image id=\"img_id3156253\" src=\"starmath/res/bi21305.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3156253\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3150068.68
msgid  "Less than"
msgstr ""

#: text/smath/01/03091502.xhp#par_id9464726
msgid  "\<item type=\"literal\"\><<\</item\> or \<item type=\"literal\"\>ll\</item\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3149922.80
msgid  "Much less than"
msgstr ""

#: text/smath/01/03091502.xhp#par_idN11059
msgid  "\<item type=\"literal\"\><=\</item\> or \<item type=\"literal\"\>le\</item\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3153031
msgid  "\<image id=\"img_id3153037\" src=\"starmath/res/bi21313.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3153037\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3152714.76
msgid  "Less than or equal to"
msgstr ""

#: text/smath/01/03091502.xhp#par_idN10D00
msgid  "\<item type=\"literal\"\><>\</item\> or \<item type=\"literal\"\>neq\</item\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3155548
msgid  "\<image id=\"img_id3155554\" src=\"starmath/res/bi21302.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155554\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3148672.32
msgid  "Not equal"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3150600
msgid  "\<image id=\"img_id3150606\" src=\"starmath/res/bi21301.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150606\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3155358.30
msgid  "Equation"
msgstr ""

#: text/smath/01/03091502.xhp#par_idN10E4D
msgid  "\<item type=\"literal\"\>>\</item\> or \<item type=\"literal\"\>gt\</item\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3152978
msgid  "\<image id=\"img_id3152984\" src=\"starmath/res/bi21306.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3152984\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3150515.66
msgid  "Greater than"
msgstr ""

#: text/smath/01/03091502.xhp#par_idN1109E
msgid  "\<item type=\"literal\"\>>=\</item\> or \<item type=\"literal\"\>ge\</item\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3152741
msgid  "\<image id=\"img_id3153876\" src=\"starmath/res/bi21314.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3153876\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3150308.70
msgid  "Greater than or equal to"
msgstr ""

#: text/smath/01/03091502.xhp#par_idN11183
msgid  "\<item type=\"literal\"\>>>\</item\> or \<item type=\"literal\"\>gg\</item\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3153863.74
msgid  "Much greater than"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3150840
msgid  "\<image id=\"img_id3150846\" src=\"starmath/res/bi21307.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150846\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3148622.86
msgid  "Is approximately"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3148502.82
msgid  "is defined as/by definition equal to"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3154050
msgid  "\<image id=\"img_id3154056\" src=\"starmath/res/bi21322.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154056\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3153749.375
msgid  "divides"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3150419
msgid  "\<image id=\"img_id3150425\" src=\"starmath/res/bi21324.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150425\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3163845.383
msgid  "Arrow with double line to the left"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3154424
msgid  "\<image id=\"img_id3154429\" src=\"starmath/res/bi21325.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154429\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3156166.387
msgid  "Arrow with double line to the left and the right"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3155410
msgid  "\<image id=\"img_id3155417\" src=\"starmath/res/bi21326.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155417\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3155291.385
msgid  "Arrow with double line to the right"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3153373
msgid  "\<image id=\"img_id3153379\" src=\"starmath/res/bi21303.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3153379\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3152934.84
msgid  "Is equivalent/congruent to"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3149139
msgid  "\<image id=\"img_id3149145\" src=\"starmath/res/bi21310.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149145\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3153616.72
msgid  "Greater than-equal to"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3153648
msgid  "\<image id=\"img_id3153653\" src=\"starmath/res/bi21309.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3153653\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3153690.78
msgid  "Less than-equal to"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3145098
msgid  "\<image id=\"img_id3145104\" src=\"starmath/res/bi21323.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3145104\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3150374.377
msgid  "does not divide"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3152809
msgid  "\<image id=\"img_id3150267\" src=\"starmath/res/bi21304.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150267\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3151063.94
msgid  "Is orthogonal to"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3153161
msgid  "\<image id=\"img_id3153168\" src=\"starmath/res/bi21308.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3153168\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3152784.96
msgid  "Is parallel to"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3150336
msgid  "\<image id=\"img_id3148396\" src=\"starmath/res/bi21312.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3148396\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3153930.92
msgid  "Is proportional to"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3154416
msgid  "\<image id=\"img_id3154422\" src=\"starmath/res/bi21315.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154422\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3145154.88
msgid  "Is similar to"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3149265
msgid  "\<image id=\"img_id3149271\" src=\"starmath/res/bi21311.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149271\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3151346.90
msgid  "Is similar or equal to"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3153957
msgid  "\<image id=\"img_id3153962\" src=\"starmath/res/bi21316.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3153962\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3155844.134
msgid  "Toward"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3152853.98
msgid  "Correspondence symbol image of"
msgstr ""

#: text/smath/01/03091502.xhp#par_id3157974.100
msgid  "Correspondence symbol original of"
msgstr ""

#: text/smath/01/03091503.xhp#tit
msgid  "Set Operators"
msgstr ""

#: text/smath/01/03091503.xhp#bm_id3157991
msgid  "\<bookmark_value\>set operators;list of\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091503.xhp#hd_id4201178
msgid  "\<variable id=\"set\"\>\<link href=\"text/smath/01/03091503.xhp\" name=\"set\"\>Set Operators\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_idN1130F
msgid  "Typed command(s)"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3145724.478
msgid  "Symbol in Elements Window"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158137.480
msgid  "Meaning"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3146505
msgid  "\<image id=\"img_id3146512\" src=\"starmath/res/op22001.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3146512\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3146625.214
msgid  "Cardinal number"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3159379
msgid  "\<image id=\"img_id3159386\" src=\"starmath/res/op22002.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3159386\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3152374.218
msgid  "Empty set"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158166
msgid  "\<image id=\"img_id3158173\" src=\"starmath/res/op21401.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3158173\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3155037.102
msgid  "is contained in"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3152402
msgid  "\<image id=\"img_id3152408\" src=\"starmath/res/op21405.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3152408\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3152522.126
msgid  "Intersection of sets"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158212
msgid  "\<image id=\"img_id3158218\" src=\"starmath/res/op21402.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3158218\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158332.104
msgid  "is not contained in"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158819
msgid  "\<image id=\"img_id3158825\" src=\"starmath/res/op21413.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3158825\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158939.110
msgid  "Not subset to"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158966
msgid  "\<image id=\"img_id3158973\" src=\"starmath/res/op21414.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3158973\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3159086.112
msgid  "Not subset or equal to"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3159114
msgid  "\<image id=\"img_id3159120\" src=\"starmath/res/op21415.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3159120\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3162974.118
msgid  "Not superset"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3163002
msgid  "\<image id=\"img_id3163008\" src=\"starmath/res/op21416.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3163008\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3163122.120
msgid  "Not superset or equal to"
msgstr ""

#: text/smath/01/03091503.xhp#par_idN112D9
msgid  "\<item type=\"literal\"\>owns\</item\> or \<item type=\"literal\"\>ni\</item\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158359
msgid  "\<image id=\"img_id3158366\" src=\"starmath/res/op21403.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3158366\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3159352.122
msgid  "Contains"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3156480
msgid  "\<image id=\"img_id3156486\" src=\"starmath/res/op21421.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3156486\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3156600.405
msgid  "Complex number"
msgstr ""

#: text/smath/01/03091503.xhp#par_idN113E5
msgid  "\<item type=\"literal\"\>setminus\</item\> or \<item type=\"literal\"\>bslash\</item\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3145932
msgid  "\<image id=\"img_id3145938\" src=\"starmath/res/op21407.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3145938\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3146052.128
msgid  "Difference between sets"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3163149
msgid  "\<image id=\"img_id3163156\" src=\"starmath/res/op21417.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3163156\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3163269.397
msgid  "Natural number"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3163444
msgid  "\<image id=\"img_id3163450\" src=\"starmath/res/op21419.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3163450\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3163564.401
msgid  "Rational number"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3163591
msgid  "\<image id=\"img_id3163598\" src=\"starmath/res/op21420.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3163598\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3156453.403
msgid  "Real number"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3163296
msgid  "\<image id=\"img_id3163303\" src=\"starmath/res/op21418.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3163303\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3163416.399
msgid  "Integer"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3146357
msgid  "\<image id=\"img_id3146363\" src=\"starmath/res/op21408.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3146363\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3146477.54
msgid  "Slash / for quotient set (slash) between characters"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3146652
msgid  "\<image id=\"img_id3146659\" src=\"starmath/res/op21409.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3146659\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3146772.106
msgid  "Subset"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3146800
msgid  "\<image id=\"img_id3146806\" src=\"starmath/res/op21410.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3146806\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158496.108
msgid  "Subset or equal to"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158524
msgid  "\<image id=\"img_id3158530\" src=\"starmath/res/op21411.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3158530\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158644.114
msgid  "Superset"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158671
msgid  "\<image id=\"img_id3158678\" src=\"starmath/res/op21412.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3158678\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3158791.116
msgid  "Superset or equal to"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3152548
msgid  "\<image id=\"img_id3152555\" src=\"starmath/res/op21406.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3152555\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091503.xhp#par_id3145904.124
msgid  "Union of sets"
msgstr ""

#: text/smath/01/03091504.xhp#tit
msgid  "Functions"
msgstr ""

#: text/smath/01/03091504.xhp#bm_id3156617
msgid  "\<bookmark_value\>functions operators;list of\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091504.xhp#hd_id645466
msgid  "\<variable id=\"functions\"\>\<link href=\"text/smath/01/03091504.xhp\" name=\"Functions\"\>Functions\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_idN11838
msgid  "Typed command(s)"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3156681.481
msgid  "Symbol in Elements Window"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3156750.483
msgid  "Meaning"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3166018
msgid  "\<image id=\"img_id3166024\" src=\"starmath/res/fu21501.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3166024\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3166138.16
msgid  "Absolute amount"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3164840
msgid  "\<image id=\"img_id3164847\" src=\"starmath/res/fu21518.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3164847\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3164961.184
msgid  "Inverse cosine or arccosine"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165134
msgid  "\<image id=\"img_id3165141\" src=\"starmath/res/fu21520.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3165141\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165255.188
msgid  "Inverse cotangent or arccotangent"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3166312
msgid  "\<image id=\"img_id3166318\" src=\"starmath/res/fu21522.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3166318\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3166432.200
msgid  "Inverse hyperbolic cosine"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3143430
msgid  "\<image id=\"img_id3143436\" src=\"starmath/res/fu21524.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3143436\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3143550.204
msgid  "Inverse hyperbolic cotangent"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3152238
msgid  "\<image id=\"img_id3152244\" src=\"starmath/res/fu21517.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3152244\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3152358.182
msgid  "Inverse sine or arcsine"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3164987
msgid  "\<image id=\"img_id3164994\" src=\"starmath/res/fu21519.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3164994\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165108.186
msgid  "Inverse tangent or arctangent"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3166165
msgid  "\<image id=\"img_id3166172\" src=\"starmath/res/fu21521.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3166172\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3166285.198
msgid  "Inverse hyperbolic sine"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3166459
msgid  "\<image id=\"img_id3166465\" src=\"starmath/res/fu21523.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3166465\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3143403.202
msgid  "Inverse hyperbolic tangent"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3143805.216
msgid  "Back epsilon"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3151649
msgid  "\<image id=\"img_id3151656\" src=\"starmath/res/fu21510.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151656\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3151770.176
msgid  "Cosine"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165576
msgid  "\<image id=\"img_id3165583\" src=\"starmath/res/fu21514.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3165583\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165696.192
msgid  "Hyperbolic cosine"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3151944
msgid  "\<image id=\"img_id3151950\" src=\"starmath/res/fu21512.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151950\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3152064.180
msgid  "Cotangent"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165871
msgid  "\<image id=\"img_id3165877\" src=\"starmath/res/fu21516.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3165877\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165991.196
msgid  "Hyperbolic cotangent"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3157074
msgid  "\<image id=\"img_id3157080\" src=\"starmath/res/fu21507.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3157080\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3157194.206
msgid  "General exponential function"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3143577
msgid  "\<image id=\"img_id3143584\" src=\"starmath/res/fu21502.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3143584\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3143698.18
msgid  "Factorial"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3156780
msgid  "\<image id=\"img_id3156786\" src=\"starmath/res/fu21505.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3156786\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3156900.212
msgid  "Natural exponential function"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3156927
msgid  "\<image id=\"img_id3156934\" src=\"starmath/res/fu21506.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3156934\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3157048.208
msgid  "Natural logarithm"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3157220
msgid  "\<image id=\"img_id3157227\" src=\"starmath/res/fu21508.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3157227\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3157341.210
msgid  "General logarithm"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165282
msgid  "\<image id=\"img_id3165288\" src=\"starmath/res/fu21504.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3165288\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165402.22
msgid  "n-th root of x"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3151502
msgid  "\<image id=\"img_id3151509\" src=\"starmath/res/fu21509.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151509\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3151623.174
msgid  "Sine"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165429
msgid  "\<image id=\"img_id3165436\" src=\"starmath/res/fu21513.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3165436\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165549.190
msgid  "Hyperbolic sine"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3152091
msgid  "\<image id=\"img_id3152097\" src=\"starmath/res/fu21503.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3152097\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3152211.20
msgid  "Square root"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3143914.130
msgid  "x with subscript n"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3157368
msgid  "\<image id=\"img_id3157375\" src=\"starmath/res/fu21908.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3157375\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3151476.132
msgid  "n-th power of x"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3151796
msgid  "\<image id=\"img_id3151803\" src=\"starmath/res/fu21511.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151803\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3151917.178
msgid  "Tangent"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165723
msgid  "\<image id=\"img_id3165730\" src=\"starmath/res/fu21515.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3165730\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091504.xhp#par_id3165844.194
msgid  "Hyperbolic tangent"
msgstr ""

#: text/smath/01/03091505.xhp#tit
msgid  "Operators"
msgstr ""

#: text/smath/01/03091505.xhp#bm_id3156617
msgid  "\<bookmark_value\>operators;list of\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091505.xhp#hd_id1328165
msgid  "\<variable id=\"operators\"\>\<link href=\"text/smath/01/03091505.xhp\" name=\"Operators\"\>Operators\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_idN11DE4
msgid  "Typed command(s)"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3143994.484
msgid  "Symbol in Elements Window"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144064.486
msgid  "Meaning"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144534
msgid  "\<image id=\"img_id3144541\" src=\"starmath/res/fo21604.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3144541\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144655.142
msgid  "Coproduct"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3166611
msgid  "\<image id=\"img_id3166618\" src=\"starmath/res/fo21614.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3166618\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3166692.170
msgid  "Lower limit of an operator"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144681
msgid  "\<image id=\"img_id3144688\" src=\"starmath/res/fo21613.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3144688\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144763.168
msgid  "Range from ... to"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3145083
msgid  "\<image id=\"img_id3166470\" src=\"starmath/res/fo21607.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3166470\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3166584.158
msgid  "Triple integral"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144936
msgid  "\<image id=\"img_id3144943\" src=\"starmath/res/fo21606.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3144943\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3145056.156
msgid  "Double integral"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144789
msgid  "\<image id=\"img_id3144796\" src=\"starmath/res/fo21605.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3144796\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144909.154
msgid  "Integral"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3167350.146
msgid  "Limes inferior"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3167458.148
msgid  "Limes superior"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3166719
msgid  "\<image id=\"img_id3166725\" src=\"starmath/res/fo21609.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3166725\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3166839.160
msgid  "Curve integral"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3166866
msgid  "\<image id=\"img_id3166872\" src=\"starmath/res/fo21610.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3166872\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3166986.162
msgid  "Double curve integral"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3167013
msgid  "\<image id=\"img_id3167020\" src=\"starmath/res/fo21611.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3167020\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3167134.164
msgid  "Triple curve integral"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3167527.166
msgid  "Placeholder, user-defined operator"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144387
msgid  "\<image id=\"img_id3144394\" src=\"starmath/res/fo21603.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3144394\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144508.140
msgid  "Product"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144240
msgid  "\<image id=\"img_id3144247\" src=\"starmath/res/fo21602.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3144247\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144361.138
msgid  "Sum"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3167161
msgid  "\<image id=\"img_id3167167\" src=\"starmath/res/fo21615.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3167167\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3167242.172
msgid  "Upper limit of an operator"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144093
msgid  "\<image id=\"img_id3144100\" src=\"starmath/res/fo21601.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3144100\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091505.xhp#par_id3144214.144
msgid  "Limes"
msgstr ""

#: text/smath/01/03091506.xhp#tit
msgid  "Attributes"
msgstr ""

#: text/smath/01/03091506.xhp#bm_id3167544
msgid  "\<bookmark_value\>attributes; list of\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091506.xhp#hd_id2846156
msgid  "\<variable id=\"attributes\"\>\<link href=\"text/smath/01/03091506.xhp\" name=\"Attributes\"\>Attributes\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_idN12175
msgid  "Typed command(s)"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3167610.487
msgid  "Symbol in Elements Window"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3167680.489
msgid  "Meaning"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3167709
msgid  "\<image id=\"img_id3167716\" src=\"starmath/res/at21701.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3167716\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3167830.309
msgid  "Accent to top right above a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3159771
msgid  "\<image id=\"img_id3159778\" src=\"starmath/res/at21705.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3159778\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3159892.311
msgid  "Horizontal bar above a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3161361
msgid  "\<image id=\"img_id3161367\" src=\"res/commandimagelist/sc_bold.png\" width=\"0.222inch\" height=\"0.222inch\"\>\<alt id=\"alt_id3161367\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3161442.341
msgid  "Bold"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3168153
msgid  "\<image id=\"img_id3168160\" src=\"starmath/res/at21704.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3168160\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3168274.313
msgid  "Top open arc above a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3168006
msgid  "\<image id=\"img_id3168012\" src=\"starmath/res/at21703.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3168012\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3168127.315
msgid  "Upside down roof"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3168303
msgid  "\<image id=\"img_id3168309\" src=\"starmath/res/at21709.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3168309\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3168424.317
msgid  "Circle above a character"
msgstr ""

#: text/smath/01/03091506.xhp#bm_id3161843
msgid  "\<bookmark_value\>formulas;in color\</bookmark_value\>\<bookmark_value\>colors;in formulas\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3161843.349
msgid  "The \<emph\>color\</emph\> command changes the character color; first enter the \<emph\>color\</emph\> command directly in the \<emph\>Commands\</emph\> window. Then enter the color name (black, white, cyan, magenta, red, blue, green, or yellow). Then enter the characters to be changed."
msgstr ""

#: text/smath/01/03091506.xhp#par_id3161104
msgid  "\<image id=\"img_id3161111\" src=\"starmath/res/at21712.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3161111\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3161225.323
msgid  "Three dots above a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160512
msgid  "\<image id=\"img_id3160519\" src=\"starmath/res/at21711.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3160519\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160633.321
msgid  "Two dots above a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3159919
msgid  "\<image id=\"img_id3159926\" src=\"starmath/res/at21710.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3159926\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160040.319
msgid  "Dot above a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3167857
msgid  "\<image id=\"img_id3167864\" src=\"starmath/res/at21702.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3167864\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3167978.325
msgid  "Accent to bottom right above a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3159622
msgid  "\<image id=\"img_id3159628\" src=\"starmath/res/at21707.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3159628\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3159743.327
msgid  "\"Roof\" above a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3161469
msgid  "\<image id=\"img_id3161476\" src=\"res/commandimagelist/sc_italic.png\" width=\"0.222inch\" height=\"0.222inch\"\>\<alt id=\"alt_id3161476\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3161550.339
msgid  "Italics"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3162012.367
msgid  "Remove the Bold attribute"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3161943.365
msgid  "Remove the Italics attribute"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160659
msgid  "\<image id=\"img_id3160666\" src=\"starmath/res/at21713.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3160666\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160780.335
msgid  "Horizontal bar above a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160956
msgid  "\<image id=\"img_id3160962\" src=\"starmath/res/at21715.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3160962\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3161077.337
msgid  "Horizontal bar through a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3161252
msgid  "\<image id=\"img_id3161259\" src=\"starmath/res/at21716.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3161259\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3161333.343
msgid  "Phantom character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3168599
msgid  "\<image id=\"img_id3168605\" src=\"starmath/res/at21708.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3168605\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3159594.329
msgid  "Tilde above a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160808
msgid  "\<image id=\"img_id3160814\" src=\"starmath/res/at21714.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3160814\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160928.333
msgid  "Horizontal bar below a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3168451
msgid  "\<image id=\"img_id3168457\" src=\"starmath/res/im21106.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3168457\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3168572.331
msgid  "Vector arrow above a character"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160364
msgid  "\<image id=\"img_id3160370\" src=\"starmath/res/at21722.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3160370\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160485.411
msgid  "wide roof, adjusts to the character size"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160215
msgid  "\<image id=\"img_id3160222\" src=\"starmath/res/at21723.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3160222\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160336.409
msgid  "wide tilde, adjusts to the character size"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160067
msgid  "\<image id=\"img_id3160074\" src=\"starmath/res/at21724.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3160074\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091506.xhp#par_id3160188.407
msgid  "wide vector arrow, adjusts to the character size"
msgstr ""

#: text/smath/01/03091507.xhp#tit
msgid  "Others"
msgstr ""

#: text/smath/01/03091507.xhp#bm_id3156617
msgid  "\<bookmark_value\>other operators;list of\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091507.xhp#hd_id6469313
msgid  "\<variable id=\"others\"\>\<link href=\"text/smath/01/03091507.xhp\" name=\"Others\"\>Others\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_idN126E6
msgid  "Typed command(s)"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162086.490
msgid  "Symbol in Elements Window"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162156.492
msgid  "Meaning"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3180602.242
msgid  "Placeholder"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179931
msgid  "\<image id=\"img_id3179937\" src=\"starmath/res/mi22008.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3179937\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3180051.232
msgid  "Math-axis ellipsis"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3180374
msgid  "\<image id=\"img_id3180380\" src=\"starmath/res/mi22010.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3180380\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3180494.236
msgid  "Downward diagonal ellipsis"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179784
msgid  "\<image id=\"img_id3179790\" src=\"starmath/res/mi22011.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3179790\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179904.238
msgid  "Ellipsis"
msgstr ""

#: text/smath/01/03091507.xhp#par_idN127BB
msgid  "\<item type=\"literal\"\>dotsup\</item\> or \<item type=\"literal\"\>dotsdiag\</item\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3180078
msgid  "\<image id=\"img_id3180085\" src=\"starmath/res/mi22009.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3180085\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3180198.234
msgid  "Upward diagonal ellipsis"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3180226
msgid  "\<image id=\"img_id3180233\" src=\"starmath/res/mi22012.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3180233\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3180346.240
msgid  "Vertical ellipsis"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179636
msgid  "\<image id=\"img_id3179643\" src=\"starmath/res/mi22019.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3179643\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179757.391
msgid  "Down arrow"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162627
msgid  "\<image id=\"img_id3162633\" src=\"starmath/res/mi21608.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3162633\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162747.150
msgid  "Existential quantifier, there is at least one"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162775
msgid  "\<image id=\"img_id3162781\" src=\"starmath/res/mi21612.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3162781\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162895.152
msgid  "Universal quantifier, for all"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162922
msgid  "\<image id=\"img_id3178464\" src=\"starmath/res/mi22014.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3178464\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3178578.379
msgid  "h with line over it"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3178900
msgid  "\<image id=\"img_id3178906\" src=\"starmath/res/mi22004.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3178906\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179020.222
msgid  "Imaginary part of a complex number"
msgstr ""

#: text/smath/01/03091507.xhp#par_idN12939
msgid  "\<item type=\"literal\"\>infinity\</item\> or \<item type=\"literal\"\>infty\</item\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162185
msgid  "\<image id=\"img_id3162192\" src=\"starmath/res/mi22005.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3162192\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162305.224
msgid  "Infinite"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3178604
msgid  "\<image id=\"img_id3178611\" src=\"starmath/res/mi22015.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3178611\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3178724.381
msgid  "Lambda with line over it"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179195
msgid  "\<image id=\"img_id3179201\" src=\"starmath/res/mi22016.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3179201\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179315.393
msgid  "Left arrow"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162480
msgid  "\<image id=\"img_id3162486\" src=\"starmath/res/mi22013.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3162486\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162600.226
msgid  "Nabla vector"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162332
msgid  "\<image id=\"img_id3162339\" src=\"starmath/res/mi22006.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3162339\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3162452.228
msgid  "Partial derivative or set margin"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3178752
msgid  "\<image id=\"img_id3178759\" src=\"starmath/res/mi22003.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3178759\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3178872.220
msgid  "Real part of a complex number"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179342
msgid  "\<image id=\"img_id3179349\" src=\"starmath/res/mi22017.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3179349\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179462.395
msgid  "Right arrow"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179489
msgid  "\<image id=\"img_id3179496\" src=\"starmath/res/mi22018.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3179496\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179610.389
msgid  "Up arrow"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179047
msgid  "\<image id=\"img_id3179054\" src=\"starmath/res/mi22007.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3179054\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091507.xhp#par_id3179167.230
msgid  "p function, Weierstrass p"
msgstr ""

#: text/smath/01/03091508.xhp#tit
msgid  "Brackets"
msgstr ""

#: text/smath/01/03091508.xhp#bm_id3180620
msgid  "\<bookmark_value\>brackets; reference list\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091508.xhp#hd_id4631488
msgid  "\<variable id=\"brackets\"\>\<link href=\"text/smath/01/03091508.xhp\" name=\"Brackets\"\>Brackets\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_idN12B53
msgid  "Typed command(s)"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3180684.493
msgid  "Symbol in Elements Window"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3180753.495
msgid  "Meaning"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3180783
msgid  "\<image id=\"img_id3180789\" src=\"starmath/res/al21801.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3180789\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3180903.249
msgid  "Normal round left and right bracket"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3180930
msgid  "\<image id=\"img_id3180936\" src=\"starmath/res/al21802.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3180936\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181050.252
msgid  "Left and right square bracket"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181078
msgid  "\<image id=\"img_id3181084\" src=\"starmath/res/al21823.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3181084\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181201.417
msgid  "Left and right square double bracket"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181229
msgid  "\<image id=\"img_id3181235\" src=\"starmath/res/al21805.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3181235\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181350.259
msgid  "Left and right vertical line"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181377
msgid  "\<image id=\"img_id3181384\" src=\"starmath/res/al21806.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3181384\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181498.261
msgid  "Left and right double vertical lines"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181525
msgid  "\<image id=\"img_id3181532\" src=\"starmath/res/al21804.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3181532\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181646.255
msgid  "Left and right curly brackets, set bracket"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181674
msgid  "\<image id=\"img_id3181680\" src=\"starmath/res/al21803.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3181680\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181794.257
msgid  "Left and right pointed bracket"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181822
msgid  "\<image id=\"img_id3181828\" src=\"starmath/res/al21821.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3181828\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181945.423
msgid  "Left and right pointed operator bracket"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3181973
msgid  "\<image id=\"img_id3181980\" src=\"starmath/res/al21808.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3181980\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182055.246
msgid  "Left and right group bracket. They are not displayed in the document and do not take up any room."
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182083
msgid  "\<image id=\"img_id3182090\" src=\"starmath/res/al21809.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3182090\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182178.267
msgid  "Brackets, scalable"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182210
msgid  "\<image id=\"img_id3182216\" src=\"starmath/res/al21810.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3182216\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182305.449
msgid  "Square brackets, scalable"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182332
msgid  "\<image id=\"img_id3182339\" src=\"starmath/res/al21824.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3182339\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182428.452
msgid  "Double square brackets, scalable"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182456
msgid  "\<image id=\"img_id3182463\" src=\"starmath/res/al21812.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3182463\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182551.455
msgid  "Braces, scalable"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182579
msgid  "\<image id=\"img_id3182586\" src=\"starmath/res/al21813.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3182586\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182674.458
msgid  "Single lines, scalable"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182702
msgid  "\<image id=\"img_id3182709\" src=\"starmath/res/al21814.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3182709\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182797.461
msgid  "Double lines, scalable"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182825
msgid  "\<image id=\"img_id3182832\" src=\"starmath/res/al21811.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3182832\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182920.464
msgid  "Angle brackets, scalable"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3182948
msgid  "\<image id=\"img_id3182955\" src=\"starmath/res/al21822.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3182955\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183043.425
msgid  "Scalable left and right pointed operator bracket"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183072
msgid  "\<image id=\"img_id3183078\" src=\"starmath/res/al21825.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3183078\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183195.419
msgid  "Scalable curly set bracket on top"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183223
msgid  "\<image id=\"img_id3183230\" src=\"starmath/res/al21826.png\" width=\"0.25inch\" height=\"0.25inch\"\>\<alt id=\"alt_id3183230\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183346.421
msgid  "Scalable curly set bracket below"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183456.263
msgid  "Left and right line with lower edges"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183565.265
msgid  "Left and right line with upper edges"
msgstr ""

#: text/smath/01/03091508.xhp#par_idN12F9F
msgid  "\<item type=\"literal\"\>\\\\lbrace \\\\rbrace\</item\> or \<item type=\"literal\"\>\\\\{ \\\\}\</item\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183648.269
msgid  "Left curly bracket or right curly bracket"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183733.271
msgid  "Left and right round bracket"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183817.273
msgid  "Left and right square bracket"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183901.275
msgid  "Left and right pointed bracket"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3183985.277
msgid  "Left and right vertical line"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3184069.279
msgid  "Left and right double line"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3184153.281
msgid  "Left and right line with lower edges"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3184237.283
msgid  "Left and right line with upper edges"
msgstr ""

#: text/smath/01/03091508.xhp#par_id3985717
msgid  "\<item type=\"literal\"\>none\</item\>"
msgstr ""

#: text/smath/01/03091508.xhp#par_id1778008
msgid  "Qualifier to suppress one bracket, as in \<item type=\"literal\"\>right none \</item\>"
msgstr ""

#: text/smath/01/03091509.xhp#tit
msgid  "Formatting"
msgstr ""

#: text/smath/01/03091509.xhp#bm_id3184255
msgid  "\<bookmark_value\>formatting; reference list (Math)\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091509.xhp#hd_id1155735
msgid  "\<variable id=\"formatting\"\>\<link href=\"text/smath/01/03091509.xhp\" name=\"Formatting\"\>Formatting\</link\>\</variable\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_idN1308F
msgid  "Typed command(s)"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3184320.496
msgid  "Symbol in Elements Window"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3184389.498
msgid  "Meaning"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3184418
msgid  "\<image id=\"img_id3184425\" src=\"starmath/res/co21916.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3184425\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3184540.295
msgid  "Left exponent"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3184566
msgid  "\<image id=\"img_id3184572\" src=\"starmath/res/co21918.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3184572\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3184690.369
msgid  "Exponent directly above a character"
msgstr ""

#: text/smath/01/03091509.xhp#par_idN13117
msgid  "\<item type=\"literal\"\>^\</item\> or \<item type=\"literal\"\>sup\</item\> or \<item type=\"literal\"\>rsup\</item\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3184717
msgid  "\<image id=\"img_id3184724\" src=\"starmath/res/co21908.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3184724\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3184838.291
msgid  "Right exponent"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3184864
msgid  "\<image id=\"img_id3184871\" src=\"starmath/res/co21905.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3184871\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3184985.303
msgid  "Binom"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185011
msgid  "\<image id=\"img_id3185018\" src=\"starmath/res/co21901.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3185018\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185093.301
msgid  "New line"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185119
msgid  "\<image id=\"img_id3185126\" src=\"starmath/res/co21912.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3185126\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185240.293
msgid  "Left index"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185267
msgid  "\<image id=\"img_id3185274\" src=\"starmath/res/co21917.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3185274\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185391.371
msgid  "Index directly below a character"
msgstr ""

#: text/smath/01/03091509.xhp#par_idN1322D
msgid  "\<item type=\"literal\"\>_\</item\> or \<item type=\"literal\"\>sub\</item\> or \<item type=\"literal\"\>rsub\</item\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185418
msgid  "\<image id=\"img_id3185425\" src=\"starmath/res/co21904.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3185425\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185539.289
msgid  "Right index"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185566
msgid  "\<image id=\"img_id3185573\" src=\"starmath/res/co21906.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3185573\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185687.305
msgid  "Stack"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185714
msgid  "\<image id=\"img_id3185721\" src=\"starmath/res/co21902.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3185721\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185796.299
msgid  "Small space/small blank"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185823
msgid  "\<image id=\"img_id3185829\" src=\"starmath/res/co21909.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3185829\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185904.285
msgid  "Align left"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3185931
msgid  "\<image id=\"img_id3185937\" src=\"starmath/res/co21910.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3185937\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3186012.469
msgid  "Align to horizontal center"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3186039
msgid  "\<image id=\"img_id3186046\" src=\"starmath/res/co21911.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3186046\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3186120.471
msgid  "Align right"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3186147
msgid  "\<image id=\"img_id3186154\" src=\"starmath/res/co21907.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3186154\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3186267.307
msgid  "Matrix"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3186295
msgid  "\<image id=\"img_id3186302\" src=\"starmath/res/co21903.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3186302\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091509.xhp#par_id3186377.297
msgid  "Wide space/gap"
msgstr ""

#: text/smath/01/03091509.xhp#par_id318637799
msgid  "Suppress horizontal space between elements"
msgstr ""

#: text/smath/01/03091600.xhp#tit
msgid  "Other Symbols"
msgstr ""

#: text/smath/01/03091600.xhp#bm_id3149261
msgid  "\<bookmark_value\>mathematical symbols; other\</bookmark_value\>\<bookmark_value\>real part of complex numbers\</bookmark_value\>\<bookmark_value\>symbols;for complex numbers\</bookmark_value\>\<bookmark_value\>partial differentiation symbol\</bookmark_value\>\<bookmark_value\>infinity symbol\</bookmark_value\>\<bookmark_value\>Nabla operator\</bookmark_value\>\<bookmark_value\>there exists symbol\</bookmark_value\>\<bookmark_value\>existence quantor symbol\</bookmark_value\>\<bookmark_value\>for all symbol\</bookmark_value\>\<bookmark_value\>universal quantifier symbol\</bookmark_value\>\<bookmark_value\>h-bar symbol\</bookmark_value\>\<bookmark_value\>lambda-bar symbol\</bookmark_value\>\<bookmark_value\>imaginary part of a complex number\</bookmark_value\>\<bookmark_value\>complex numbers; symbols\</bookmark_value\>\<bookmark_value\>weierstrass p symbol\</bookmark_value\>\<bookmark_value\>left arrow symbol\</bookmark_value\>\<bookmark_value\>right arrow symbol\</bookmark_value\>\<bookmark_value\>up arrow symbol\</bookmark_value\>\<bookmark_value\>down arrow symbol\</bookmark_value\>\<bookmark_value\>arrows;symbols in %PRODUCTNAME Math\</bookmark_value\>\<bookmark_value\>center dots symbol\</bookmark_value\>\<bookmark_value\>axis-ellipsis\</bookmark_value\>\<bookmark_value\>vertical dots symbol\</bookmark_value\>\<bookmark_value\>diagonal upward dots;symbol\</bookmark_value\>\<bookmark_value\>diagonal downward dots;symbol\</bookmark_value\>\<bookmark_value\>epsilon; back\</bookmark_value\>\<bookmark_value\>back epsilon symbol\</bookmark_value\>\<bookmark_value\>placeholders; inserting in formulas\</bookmark_value\>\<bookmark_value\>ellipsis symbols\</bookmark_value\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3149261.1
msgid  "\<link href=\"text/smath/01/03091600.xhp\" name=\"Other Symbols\"\>Other Symbols\</link\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3157884.2
msgid  "\<ahelp hid=\"HID_SMA_MISC_MENU\"\>Shows miscellaneous mathematical symbols.\</ahelp\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3156430.3
msgid  "Symbols in detail"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3145171
msgid  "\<image id=\"img_id3145177\" src=\"starmath/res/mi22006.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3145177\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3153167.44
msgid  "Partial"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3156303.5
msgid  "\<ahelp hid=\"HID_SMA_PARTIAL\"\>Inserts the symbol for a partial differentiation.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>partial\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3152782
msgid  "\<image id=\"img_id3152788\" src=\"starmath/res/mi22005.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3152788\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3151049.43
msgid  "Infinity"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3153648.6
msgid  "\<ahelp hid=\"HID_SMA_INFINITY\"\>Inserts the symbol for infinity.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>infinity\</emph\> or \<emph\>infty\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3150217
msgid  "\<image id=\"img_id3150223\" src=\"starmath/res/mi22013.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3150223\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3153687.45
msgid  "Nabla"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3149735.16
msgid  "\<ahelp hid=\"HID_SMA_NABLA\"\>Inserts the symbol for a Nabla vector operator.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>nabla\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3155330
msgid  "\<image id=\"img_id3155336\" src=\"starmath/res/mi21608.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155336\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3154398.46
msgid  "There exists"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3156346.41
msgid  "\<ahelp hid=\"HID_SMA_EXISTS\"\>Inserts the symbol for an Existence quantor.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>exists\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3151296
msgid  "\<image id=\"img_id3151302\" src=\"starmath/res/mi21612.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3151302\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3146976.47
msgid  "For all"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3150478.69
msgid  "\<ahelp hid=\"HID_SMA_FORALL\"\>Inserts the symbol for a universal quantifier \"for all\".\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>forall\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3153023
msgid  "\<image id=\"img_id3153030\" src=\"starmath/res/mi22014.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3153030\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3159250.58
msgid  "h Bar"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3159264.57
msgid  "\<ahelp hid=\"HID_SMA_HBAR\"\>Inserts the symbol for the h-bar constant.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>hbar\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3153908
msgid  "\<image id=\"img_id3153256\" src=\"starmath/res/mi22015.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3153256\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3145378.60
msgid  "Lambda Bar"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3150338.59
msgid  "\<ahelp hid=\"HID_SMA_LAMBDABAR\"\>Inserts the symbol for a lambda-bar.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>lambdabar\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3150651
msgid  "\<image id=\"img_id3154285\" src=\"starmath/res/mi22003.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154285\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3153962.48
msgid  "Real Part"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3148610.7
msgid  "\<ahelp hid=\"HID_SMA_RE\"\>Inserts the symbol for the real part of a complex number.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>re\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3154543
msgid  "\<image id=\"img_id3154553\" src=\"starmath/res/mi22004.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154553\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3150430.49
msgid  "Imaginary Part"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3147036.8
msgid  "\<ahelp hid=\"HID_SMA_IM\"\>Inserts the symbol for the imaginary part of a complex number.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>im\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3154156
msgid  "\<image id=\"img_id3154162\" src=\"starmath/res/mi22007.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3154162\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3156177.51
msgid  "Weierstrass p"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3155435.10
msgid  "\<ahelp hid=\"HID_SMA_WP\"\>This icon inserts a Weierstrass p-function symbol.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>wp\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3155267
msgid  "\<image id=\"img_id3155273\" src=\"starmath/res/mi22016.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155273\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3153860.62
msgid  "Left Arrow"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3146122.61
msgid  "\<ahelp hid=\"HID_SMA_LEFTARROW\"\>This icon inserts a left arrow.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>leftarrow\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3149923
msgid  "\<image id=\"img_id3149929\" src=\"starmath/res/mi22017.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3149929\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3153472.64
msgid  "Right Arrow"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3155472.63
msgid  "\<ahelp hid=\"HID_SMA_RIGHTARROW\"\>This icon inserts a right arrow.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>rightarrow\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3148506
msgid  "\<image id=\"img_id3148512\" src=\"starmath/res/mi22018.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3148512\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3152824.66
msgid  "Up Arrow"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3152866.65
msgid  "\<ahelp hid=\"HID_SMA_UPARROW\"\>This icon inserts an up arrow.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>uparrow\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3157946
msgid  "\<image id=\"img_id3157951\" src=\"starmath/res/mi22019.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3157951\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3145694.68
msgid  "Down Arrow"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3145735.67
msgid  "\<ahelp hid=\"HID_SMA_DOWNARROW\"\>This icon inserts a down arrow.\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>downarrow\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3154997
msgid  "\<image id=\"img_id3155003\" src=\"starmath/res/mi22011.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3155003\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3159083.52
msgid  "Ellipsis"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3159124.11
msgid  "\<ahelp hid=\"HID_SMA_DOTSLOW\"\>This icon inserts an ellipsis (three low horizontal dots).\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>dotslow\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3163719
msgid  "\<image id=\"img_id3163726\" src=\"starmath/res/mi22008.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3163726\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3163797.53
msgid  "Math-axis Ellipsis"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3146757.12
msgid  "\<ahelp hid=\"HID_SMA_DOTSAXIS\"\>This icon inserts an axis-ellipsis (three vertically centered horizontal dots).\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>dotsaxis\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3146829
msgid  "\<image id=\"img_id3146835\" src=\"starmath/res/mi22012.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3146835\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3152634.54
msgid  "Vertical Ellipsis"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3152676.13
msgid  "\<ahelp hid=\"HID_SMA_DOTSVERT\"\>This icon inserts a vertical ellipsis (three vertical dots).\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>dotsvert\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3109675
msgid  "\<image id=\"img_id3109681\" src=\"starmath/res/mi22009.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3109681\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3109753.55
msgid  "Upward Diagonal Ellipsis"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3109794.14
msgid  "\<ahelp hid=\"HID_SMA_DOTSUP\"\>This icon inserts an upward diagonal ellipsis (three dots on the diagonal from the bottom left to the top right)\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>dotsup\</emph\> or \<emph\>dotsdiag\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3158234
msgid  "\<image id=\"img_id3158240\" src=\"starmath/res/mi22010.png\" width=\"0.3335inch\" height=\"0.3335inch\"\>\<alt id=\"alt_id3158240\"\>Icon\</alt\>\</image\>"
msgstr ""

#: text/smath/01/03091600.xhp#hd_id3158311.56
msgid  "Downward Diagonal Ellipsis"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3158353.15
msgid  "\<ahelp hid=\"HID_SMA_DOTSDOWN\"\>This icon inserts a downward diagonal ellipsis (three dots on the diagonal from upper left to lower right).\</ahelp\>Command for the \<emph\>Commands\</emph\> window: \<emph\>dotsdown\</emph\>"
msgstr ""

#: text/smath/01/03091600.xhp#par_id3158389.17
msgid  "A \<emph\>back epsilon\</emph\> can be inserted by typing \<emph\>backepsilon\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/03091600.xhp#par_id3158042.18
msgid  "To insert a placeholder into your formula, type \<emph\><?>\</emph\> in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/05010000.xhp#tit
msgid  "Fonts"
msgstr ""

#: text/smath/01/05010000.xhp#bm_id3156261
msgid  "\<bookmark_value\>fonts; in $[officename] Math\</bookmark_value\>\<bookmark_value\>formula fonts; defining\</bookmark_value\>\<bookmark_value\>defining; formula fonts\</bookmark_value\>"
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3156261.1
msgid  "Fonts"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3153716.2
msgid  "\<variable id=\"schriftartentext\"\>\<ahelp hid=\"SID_FONT\"\>Defines the fonts that can be applied to formula elements.\</ahelp\>\</variable\>"
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3154639.3
msgid  "Formula Fonts"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3151187.4
msgid  "You can define fonts for the variables, functions, numbers and inserted text that form the elements of your formula."
msgstr ""

#: text/smath/01/05010000.xhp#par_id3156318.5
msgid  "The list boxes in the \<emph\>Fonts\</emph\> dialog display a default font for all elements. To change to a different font, click \<emph\>Modify\</emph\>, then select the element type. A new dialog box appears. Select the desired font and check any desired attributes, then click \<emph\>OK\</emph\>. To set the changes as the default fonts, click the \<emph\>Default\</emph\> button."
msgstr ""

#: text/smath/01/05010000.xhp#par_id3148831.6
msgid  "If you want to mark individual text segments with a font other than that used for the whole text, then enter the \<link href=\"text/smath/01/05010000.xhp\" name=\"FONT\"\>Font\</link\> command in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3154262.7
msgid  "Variables"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3147516.8
msgid  "\<ahelp hid=\"STARMATH_LISTBOX_RID_FONTTYPEDIALOG_1\"\>You can select the fonts for the variables in your formula.\</ahelp\> For example, in the formula x=SIN(y), x and y are variables, and will reflect the assigned font."
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3150708.9
msgid  "Functions"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3152950.10
msgid  "\<ahelp hid=\"STARMATH:LISTBOX:RID_FONTTYPEDIALOG:2\"\>Select the fonts for names and properties of functions.\</ahelp\> For example, the functions in the formula x=SIN(y) are =SIN( )."
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3149805.11
msgid  "Numbers"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3154610.12
msgid  "\<ahelp hid=\"STARMATH:LISTBOX:RID_FONTTYPEDIALOG:3\"\>You can select the fonts for the numbers in your formula.\</ahelp\>"
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3153529.13
msgid  "Text"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3153780.14
msgid  "\<ahelp hid=\"STARMATH:LISTBOX:RID_FONTTYPEDIALOG:4\"\>Define the fonts for the text in your formula here.\</ahelp\>"
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3152963.15
msgid  "Custom Fonts"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3154566.16
msgid  "In this section of the \<emph\>Fonts\</emph\> dialog you can define fonts, with which you can format other text components in the formula. The three basic fonts \<emph\>Serif, Sans\</emph\> and \<emph\>Fixed\</emph\> are available. You can add any other font to each standard installed basic font. Every font installed on your system is available for you to use. Select the \<emph\>Modify\</emph\> button to expand the selection offered in the list box."
msgstr ""

#: text/smath/01/05010000.xhp#par_id3151315.17
msgid  "These custom fonts are used if you set a different font with the FONT command in the \<emph\>Commands\</emph\> window. "
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3153670.22
msgid  "Serif"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3151108.23
msgid  "\<ahelp hid=\"STARMATH:LISTBOX:RID_FONTTYPEDIALOG:5\"\>You can specify the font to be used for the \<emph\>font serif\</emph\> format.\</ahelp\> Serifs are the small \"guides\" that can be seen, for example, at the bottom of a capital A when the Times serif font is used. Using serifs is quite helpful since it guides a reader's eye in a straight line and can speed up reading."
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3150836.24
msgid  "Sans"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3155900.25
msgid  "\<ahelp hid=\"STARMATH:LISTBOX:RID_FONTTYPEDIALOG:6\"\>You can specify the font to be used for \<emph\>sans\</emph\> font formatting.\</ahelp\>"
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3149340.26
msgid  "Fixed"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3154198.27
msgid  "\<ahelp hid=\"STARMATH:LISTBOX:RID_FONTTYPEDIALOG:7\"\>You can specify the font to be used for \<emph\>fixed\</emph\> font formatting.\</ahelp\>"
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3159194.28
msgid  "Modify"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3146932.29
msgid  "\<ahelp hid=\"STARMATH:MENUBUTTON:RID_FONTTYPEDIALOG:1\"\>Click one of the choices from this pop-up menu to access the \<link href=\"text/smath/01/05010100.xhp\" name=\"Fonts\"\>Fonts\</link\> dialog, where you can define the font and attributes for the respective formula and for custom fonts.\</ahelp\>"
msgstr ""

#: text/smath/01/05010000.xhp#hd_id3149304.30
msgid  "Default"
msgstr ""

#: text/smath/01/05010000.xhp#par_id3155186.31
msgid  "\<ahelp hid=\"STARMATH:PUSHBUTTON:RID_FONTTYPEDIALOG:2\"\>Click this button to save your changes as the default for all new formulas.\</ahelp\> After confirming the changes, click the \<emph\>Yes\</emph\> button."
msgstr ""

#: text/smath/01/05010100.xhp#tit
msgid  "Fonts"
msgstr ""

#: text/smath/01/05010100.xhp#hd_id3153188.1
msgid  "Fonts"
msgstr ""

#: text/smath/01/05010100.xhp#par_id3152598.2
msgid  "\<ahelp visibility=\"visible\" hid=\"STARMATH_MODALDIALOG_RID_FONTDIALOG\"\>Use this dialog to select the font for the respective category in the \<emph\>Fonts\</emph\> dialog.\</ahelp\>"
msgstr ""

#: text/smath/01/05010100.xhp#hd_id3149124.3
msgid  "Font"
msgstr ""

#: text/smath/01/05010100.xhp#par_id3153713.4
msgid  "\<ahelp hid=\"STARMATH_COMBOBOX_RID_FONTDIALOG_1\" visibility=\"visible\"\>Select a font from the list.\</ahelp\>"
msgstr ""

#: text/smath/01/05010100.xhp#hd_id3154702.5
msgid  "Example"
msgstr ""

#: text/smath/01/05010100.xhp#par_id3154020.6
msgid  "You can see a preview of the selected font with its attributes."
msgstr ""

#: text/smath/01/05010100.xhp#hd_id3154656.7
msgid  "Attributes"
msgstr ""

#: text/smath/01/05010100.xhp#par_id3150208.8
msgid  "You can assign additional attributes to the selected font."
msgstr ""

#: text/smath/01/05010100.xhp#hd_id3154486.9
msgid  "Bold"
msgstr ""

#: text/smath/01/05010100.xhp#par_id3148839.10
msgid  "\<ahelp hid=\"STARMATH_CHECKBOX_RID_FONTDIALOG_1\" visibility=\"visible\"\>Check this box to assign the bold attribute to the font.\</ahelp\>"
msgstr ""

#: text/smath/01/05010100.xhp#hd_id3148868.11
msgid  "Italic"
msgstr ""

#: text/smath/01/05010100.xhp#par_id3149126.12
msgid  "\<ahelp hid=\"STARMATH_CHECKBOX_RID_FONTDIALOG_2\" visibility=\"visible\"\>Check this box to assign the italic attribute to the font.\</ahelp\>"
msgstr ""

#: text/smath/01/05020000.xhp#tit
msgid  "Font Sizes"
msgstr ""

#: text/smath/01/05020000.xhp#bm_id3153816
msgid  "\<bookmark_value\>font sizes; in $[officename] Math\</bookmark_value\>\<bookmark_value\>sizes; of fonts in $[officename] Math\</bookmark_value\>"
msgstr ""

#: text/smath/01/05020000.xhp#hd_id3153816.1
msgid  "Font Sizes"
msgstr ""

#: text/smath/01/05020000.xhp#par_id3150213.2
msgid  "\<variable id=\"schriftgroessentext\"\>\<ahelp hid=\"SID_FONTSIZE\"\>Use this dialog to specify the font sizes for your formula. Select a base size and all elements of the formula will be scaled in relation to this base.\</ahelp\>\</variable\>"
msgstr ""

#: text/smath/01/05020000.xhp#hd_id3146968.3
msgid  "Base size"
msgstr ""

#: text/smath/01/05020000.xhp#par_id3145115.4
msgid  "\<ahelp hid=\"STARMATH:METRICFIELD:RID_FONTSIZEDIALOG:1\"\>All elements of a formula are proportionally scaled to the base size. To change the base size, select or type in the desired point (pt) size. You can also use other units of measure or other \<link href=\"text/shared/00/00000001.xhp#metrik\" name=\"metrics\"\>metrics\</link\>, which are then automatically converted to points.\</ahelp\>"
msgstr ""

#: text/smath/01/05020000.xhp#par_id3153005.19
msgid  "To permanently change the default size (12 pt) used in $[officename] Math, you must first set the size (for example, 11 pt) and then click the \<emph\>Default\</emph\> button."
msgstr ""

#: text/smath/01/05020000.xhp#hd_id3153735.5
msgid  "Relative Sizes"
msgstr ""

#: text/smath/01/05020000.xhp#par_id3145241.6
msgid  "In this section, you can determine the relative sizes for each type of element with reference to the base size."
msgstr ""

#: text/smath/01/05020000.xhp#hd_id3150935.7
msgid  "Text"
msgstr ""

#: text/smath/01/05020000.xhp#par_id3148774.8
msgid  "\<ahelp hid=\"STARMATH:METRICFIELD:RID_FONTSIZEDIALOG:4\"\>Select the size for text in a formula relative to the base size.\</ahelp\>"
msgstr ""

#: text/smath/01/05020000.xhp#hd_id3148392.9
msgid  "Indexes"
msgstr ""

#: text/smath/01/05020000.xhp#par_id3149029.10
msgid  "\<ahelp hid=\"STARMATH:METRICFIELD:RID_FONTSIZEDIALOG:5\"\>Select the relative size for the indexes in a formula in proportion to the base size.\</ahelp\>"
msgstr ""

#: text/smath/01/05020000.xhp#hd_id3155371.11
msgid  "Functions"
msgstr ""

#: text/smath/01/05020000.xhp#par_id3153923.12
msgid  "\<ahelp hid=\"STARMATH:METRICFIELD:RID_FONTSIZEDIALOG:6\"\>Select the relative size for names and other function elements in a formula in proportion to the base size.\</ahelp\>"
msgstr ""

#: text/smath/01/05020000.xhp#hd_id3147171.13
msgid  "Operators"
msgstr ""

#: text/smath/01/05020000.xhp#par_id3083280.14
msgid  "\<ahelp hid=\"STARMATH:METRICFIELD:RID_FONTSIZEDIALOG:7\"\>Select the relative size of the mathematical operators in a formula in proportion to the base size.\</ahelp\>"
msgstr ""

#: text/smath/01/05020000.xhp#hd_id3154638.15
msgid  "Limits"
msgstr ""

#: text/smath/01/05020000.xhp#par_id3151189.16
msgid  "\<ahelp hid=\"STARMATH:METRICFIELD:RID_FONTSIZEDIALOG:8\"\>Select the relative size for the limits in a formula in proportion to the base size.\</ahelp\>"
msgstr ""

#: text/smath/01/05020000.xhp#hd_id3156320.17
msgid  "Default"
msgstr ""

#: text/smath/01/05020000.xhp#par_id3145206.18
msgid  "\<ahelp hid=\"STARMATH:PUSHBUTTON:RID_FONTSIZEDIALOG:1\"\>Click this button to save your changes as a default for all new formulas.\</ahelp\> A security response appears before saving any changes."
msgstr ""

#: text/smath/01/05030000.xhp#tit
msgid  "Spacing"
msgstr ""

#: text/smath/01/05030000.xhp#bm_id3154658
msgid  "\<bookmark_value\>spacing; formula elements\</bookmark_value\>\<bookmark_value\>formulas;element spacing\</bookmark_value\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3154658.1
msgid  "Spacing"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3153818.2
msgid  "\<variable id=\"abstaendetext\"\>\<ahelp hid=\"SID_DISTANCE\"\>Use this dialog to determine the spacing between formula elements. The spacing is specified as a percentage in relation to the base size defined under \<emph\>Format - Font Size\</emph\>.\</ahelp\>\</variable\>"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3143228.3
msgid  "Use the \<emph\>Category\</emph\> button to determine the formula element for which you would like to specify the spacing. The appearance of the dialog depends on the selected category. A preview window shows you which spacing is modified through the respective boxes."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3154653.5
msgid  "Category"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3149873.6
msgid  "\<ahelp hid=\"STARMATH:MENUBUTTON:RID_DISTANCEDIALOG:1\"\>This button allows you to select the category for which you would like to change the spacing.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3150391.7
msgid  "Spacing"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3151389.8
msgid  "Defines the spacing between variables and operators, between lines, and between root signs and radicals."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3150536.9
msgid  "Spacing"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3146323.10
msgid  "\<ahelp hid=\"HID_SMA_DEFAULT_DIST\"\>Defines the spacing between variables and operators.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3149349.11
msgid  "Line Spacing"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3145824.12
msgid  "\<ahelp hid=\"HID_SMA_LINE_DIST\"\>Determines the spacing between lines.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3145593.13
msgid  "Root Spacing"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3150864.14
msgid  "\<ahelp hid=\"HID_SMA_ROOT_DIST\"\>Determines the spacing between the root sign and radicals.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3154508.15
msgid  "Indexes"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3149885.16
msgid  "Defines the spacing for superscript and subscript indexes."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3147371.17
msgid  "Superscript"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3150568.18
msgid  "\<ahelp hid=\"HID_SMA_SUP_DIST\"\>Determines the spacing for superscript indexes.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3150933.19
msgid  "Subscript"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3148772.20
msgid  "\<ahelp hid=\"HID_SMA_SUB_DIST\"\>Determines the spacing for subscript indexes.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3149027.21
msgid  "Fractions"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3155369.22
msgid  "Defines the spacing between the fraction bar and the numerator or denominator."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3156256.23
msgid  "Numerator"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3155990.24
msgid  "\<ahelp hid=\"HID_SMA_NUMERATOR_DIST\"\>Determines the spacing between the fraction bar and the numerator.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3153722.25
msgid  "Denominator"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3149711.26
msgid  "\<ahelp hid=\"HID_SMA_DENOMINATOR_DIST\"\>Determines the spacing between the fraction bar and the denominator.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3151181.27
msgid  "Fraction Bars"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3150764.28
msgid  "Defines the excess length and line weight of the fraction bar."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3151266.29
msgid  "Excess length"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3145211.30
msgid  "\<ahelp hid=\"HID_SMA_FRACLINE_EXCWIDTH\"\>Determines the excess length of the fraction line.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3150260.31
msgid  "Weight"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3153148.32
msgid  "\<ahelp hid=\"HID_SMA_FRACLINE_LINEWIDTH\"\>Determines the weight of the fraction line.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3153627.33
msgid  "Limits"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3149755.34
msgid  "Defines the spacing between the sum symbol and the limit conditions."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3147260.35
msgid  "Upper limit"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3154690.36
msgid  "\<ahelp hid=\"HID_SMA_UPPERLIMIT_DIST\"\>Determines the spacing between the sum symbol and the upper limit.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3148834.37
msgid  "Lower limit"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3147509.38
msgid  "\<ahelp hid=\"HID_SMA_LOWERLIMIT_DIST\"\>Determines the spacing between the sum symbol and the lower limit.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3154267.39
msgid  "Brackets"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3154273.40
msgid  "Defines the spacing between brackets and the content."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3150708.41
msgid  "Excess size (left/right)"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3154106.42
msgid  "\<ahelp hid=\"HID_SMA_BRACKET_EXCHEIGHT\"\>Determines the vertical distance between the upper edge of the contents and the upper end of the brackets.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3109843.43
msgid  "Spacing"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3149810.44
msgid  "\<ahelp hid=\"HID_SMA_BRACKET_DIST\"\>Determines the horizontal distance between the contents and the upper end of the brackets.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3153531.77
msgid  "Scale all brackets"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3154799.78
msgid  "\<ahelp hid=\"STARMATH:CHECKBOX:RID_DISTANCEDIALOG:1\"\>Scales all types of brackets.\</ahelp\> If you then enter \<emph\>( a over b)\</emph\> in the \<emph\>Commands\</emph\> window, the brackets will surround the whole height of the argument. You normally achieve this effect by entering \<emph\>left ( a over b right )\</emph\>."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3151099.79
msgid  "Excess size"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3147524.80
msgid  "\<ahelp hid=\"HID_SMA_BRACKET_EXCHEIGHT2\"\>Adjusts the percentage excess size.\</ahelp\> At 0 percent the brackets are set so that they surround the argument at the same height. The higher the entered value is, the larger the vertical gap between the contents of the brackets and the external border of the brackets. The field can only be used in combination with \<emph\>Scale all brackets\</emph\>."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3153673.45
msgid  "Matrices"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3151319.46
msgid  "Defines the relative spacing for the elements in a matrix."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3150996.47
msgid  "Line spacing"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3153775.48
msgid  "\<ahelp hid=\"HID_SMA_MATRIXROW_DIST\"\>Determines the spacing between matrix elements in a row.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3152959.49
msgid  "Column spacing"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3150358.50
msgid  "\<ahelp hid=\"HID_SMA_MATRIXCOL_DIST\"\>Determines the spacing between matrix elements in a column.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3155895.51
msgid  "Symbols"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3149690.52
msgid  "Defines the spacing of symbols in relation to variables"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3149341.53
msgid  "Primary height"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3154198.54
msgid  "\<ahelp hid=\"HID_SMA_ATTRIBUT_DIST\"\>Defines the height of the symbols in relation to the baseline.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3154140.55
msgid  "Minimum spacing"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3146923.56
msgid  "\<ahelp hid=\"HID_SMA_INTERATTRIBUT_DIST\"\>Determines the minimum distance between a symbol and variable.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3149302.57
msgid  "Operators"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3155181.58
msgid  "Defines the spacing between operators and variables or numbers."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3148992.59
msgid  "Excess size"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3151333.60
msgid  "\<ahelp hid=\"HID_SMA_OPERATOR_EXCHEIGHT\"\>Determines the height from the variable to the operator's upper edge.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3149495.61
msgid  "Spacing"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3151250.62
msgid  "\<ahelp hid=\"HID_SMA_OPERATOR_DIST\"\>Determines the horizontal distance between operators and variables.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3149819.66
msgid  "Borders"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3149102.67
msgid  "Adds a border to your formula. This option is particularly useful if you want to integrate the formula into a text file in $[officename] Writer. When making settings, be sure that you do not use 0 as a size, since this creates viewing problems for text that surrounds the insertion point."
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3154837.68
msgid  "Left"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3149797.69
msgid  "\<ahelp hid=\"HID_SMA_LEFTBORDER_DIST\"\>The left border is positioned between the formula and background.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3147088.70
msgid  "Right"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3154898.71
msgid  "\<ahelp hid=\"HID_SMA_RIGHTBORDER_DIST\"\>The right border is positioned between the formula and background.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3147218.72
msgid  "Top"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3149040.73
msgid  "\<ahelp hid=\"HID_SMA_UPPERBORDER_DIST\"\>The top border is positioned between the formula and background.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3147584.74
msgid  "Bottom"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3148746.75
msgid  "\<ahelp hid=\"HID_SMA_LOWERBORDER_DIST\"\>The bottom border is positioned between the formula and background.\</ahelp\>"
msgstr ""

#: text/smath/01/05030000.xhp#hd_id3147326.63
msgid  "Default"
msgstr ""

#: text/smath/01/05030000.xhp#par_id3155143.64
msgid  "\<ahelp hid=\"SD:PUSHBUTTON:DLG_DEFINE_CUSTOMSHOW:BTN_ADD\"\>Saves your changes as your default settings for all new formulas.\</ahelp\> A security response will appear before saving these changes."
msgstr ""

#: text/smath/01/05040000.xhp#tit
msgid  "Alignment"
msgstr ""

#: text/smath/01/05040000.xhp#bm_id3148730
msgid  "\<bookmark_value\>aligning; multi-line formulas\</bookmark_value\>\<bookmark_value\>multi-line formulas; aligning\</bookmark_value\>"
msgstr ""

#: text/smath/01/05040000.xhp#hd_id3148730.1
msgid  "Alignment"
msgstr ""

#: text/smath/01/05040000.xhp#par_id3152999.2
msgid  "\<variable id=\"ausrichtungtext\"\>\<ahelp hid=\"SID_ALIGN\" visibility=\"visible\"\>You can define the alignment of multi-line formulas as well as formulas with several elements in one line.\</ahelp\> Create multi-line formulas by entering a \<emph\>NEWLINE\</emph\> command in the \<emph\>Commands\</emph\> window.\</variable\>"
msgstr ""

#: text/smath/01/05040000.xhp#hd_id3153737.3
msgid  "Horizontal"
msgstr ""

#: text/smath/01/05040000.xhp#par_id3148388.4
msgid  "Specifies the type of horizontal alignment for multi-line formulas."
msgstr ""

#: text/smath/01/05040000.xhp#hd_id3148768.5
msgid  "Left"
msgstr ""

#: text/smath/01/05040000.xhp#par_id3150566.6
msgid  "\<ahelp hid=\"STARMATH:RADIOBUTTON:RID_ALIGNDIALOG:1\" visibility=\"visible\"\>Aligns the selected elements of a formula to the left.\</ahelp\>"
msgstr ""

#: text/smath/01/05040000.xhp#par_id3149709.21
msgid  "Text is always aligned left. "
msgstr ""

#: text/smath/01/05040000.xhp#hd_id3154646.7
msgid  "Centered"
msgstr ""

#: text/smath/01/05040000.xhp#par_id3150762.8
msgid  "\<ahelp hid=\"STARMATH:RADIOBUTTON:RID_ALIGNDIALOG:2\" visibility=\"visible\"\>Aligns the elements of a formula to the center.\</ahelp\>"
msgstr ""

#: text/smath/01/05040000.xhp#hd_id3145204.9
msgid  "Right"
msgstr ""

#: text/smath/01/05040000.xhp#par_id3151264.10
msgid  "\<ahelp hid=\"STARMATH:RADIOBUTTON:RID_ALIGNDIALOG:3\" visibility=\"visible\"\>Aligns the elements of a formula to the right.\</ahelp\>"
msgstr ""

#: text/smath/01/05040000.xhp#hd_id3150261.19
msgid  "Default"
msgstr ""

#: text/smath/01/05040000.xhp#par_id3153622.20
msgid  "\<ahelp hid=\"STARMATH:PUSHBUTTON:RID_ALIGNDIALOG:1\" visibility=\"visible\"\>Click here to save your changes as the default settings for new formulas.\</ahelp\> A security response will appear before saving."
msgstr ""

#: text/smath/01/05050000.xhp#tit
msgid  "Text Mode"
msgstr ""

#: text/smath/01/05050000.xhp#bm_id3147339
msgid  "\<bookmark_value\>text mode in $[officename] Math\</bookmark_value\>\<bookmark_value\>formulas; fit to text\</bookmark_value\>"
msgstr ""

#: text/smath/01/05050000.xhp#hd_id3147339.1
msgid  "\<link href=\"text/smath/01/05050000.xhp\" name=\"Text Mode\"\>Text Mode\</link\>"
msgstr ""

#: text/smath/01/05050000.xhp#par_id3150206.2
msgid  "\<ahelp hid=\"SID_TEXTMODE\"\>Switches the text mode on or off. In text mode, formulas are displayed as the same height as a line of text.\</ahelp\>"
msgstr ""

#: text/smath/01/06010000.xhp#tit
msgid  "Catalog"
msgstr ""

#: text/smath/01/06010000.xhp#bm_id3145799
msgid  "\<bookmark_value\>symbols; entering in %PRODUCTNAME Math\</bookmark_value\>\<bookmark_value\>%PRODUCTNAME Math; entering symbols in\</bookmark_value\>\<bookmark_value\>catalog for mathematical symbols\</bookmark_value\>\<bookmark_value\>mathematical symbols;catalog\</bookmark_value\>\<bookmark_value\>Greek symbols in formulas\</bookmark_value\>\<bookmark_value\>formulas; entering symbols in\</bookmark_value\>"
msgstr ""

#: text/smath/01/06010000.xhp#hd_id3153715.1
msgid  "\<link href=\"text/smath/01/06010000.xhp\" name=\"Catalog\"\>Catalog\</link\>"
msgstr ""

#: text/smath/01/06010000.xhp#par_id3146313.2
msgid  "\<variable id=\"symboletext\"\>\<ahelp hid=\"SID_SYMBOLS_CATALOGUE\"\>Opens the \<emph\>Symbols\</emph\> dialog, in which you can select a symbol to insert in the formula.\</ahelp\>\</variable\>"
msgstr ""

#: text/smath/01/06010000.xhp#hd_id3150202.4
msgid  "Symbol Set"
msgstr ""

#: text/smath/01/06010000.xhp#par_id3148699.5
msgid  "\<ahelp hid=\"STARMATH_LISTBOX_RID_SYMBOLDIALOG_1\"\>All symbols are organized into symbol sets. Select the desired symbol set from the list box. The corresponding group of symbols appear in the field below.\</ahelp\>"
msgstr ""

#: text/smath/01/06010000.xhp#par_id3153917.7
msgid  "When a symbol is selected, its command name appears below the symbol list and a magnified version appears in a box to the right. Note that the name must be typed in the \<emph\>Commands\</emph\> window exactly as displayed here (case-sensitive)."
msgstr ""

#: text/smath/01/06010000.xhp#par_id3149126.3
msgid  "To insert a symbol, select it from the list and click \<emph\>Insert\</emph\>. The corresponding command name appears in the \<emph\>Commands\</emph\> window. "
msgstr ""

#: text/smath/01/06010000.xhp#hd_id3154765.8
msgid  "Edit"
msgstr ""

#: text/smath/01/06010000.xhp#par_id3153811.9
msgid  "\<ahelp hid=\"STARMATH_PUSHBUTTON_RID_SYMBOLDIALOG_1\"\>Click here to open the \<link href=\"text/smath/01/06010100.xhp\" name=\"Edit Symbols\"\>Edit Symbols\</link\> dialog.\</ahelp\>"
msgstr ""

#: text/smath/01/06010100.xhp#tit
msgid  "Edit Symbols"
msgstr ""

#: text/smath/01/06010100.xhp#bm_id2123477
msgid  "\<bookmark_value\>new symbols in %PRODUCTNAME Math\</bookmark_value\>\<bookmark_value\>symbols; adding in %PRODUCTNAME Math\</bookmark_value\>"
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3151075.1
msgid  "Edit Symbols"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3154513.2
msgid  "\<ahelp hid=\"STARMATH_MODALDIALOG_RID_SYMDEFINEDIALOG\"\>Use this dialog to add symbols to a symbol set, to edit symbol sets, or to modify symbol notations.\</ahelp\> You can also define new symbol sets, assign names to symbols, or to modify existing symbol sets."
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3146066.3
msgid  "Old Symbol"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3153965.4
msgid  "\<ahelp hid=\"STARMATH_COMBOBOX_RID_SYMDEFINEDIALOG_1\"\>Select the name of the current symbol.\</ahelp\> The symbol, the name of the symbol, and the set that the symbol belongs to are displayed in the left preview pane at the bottom of the dialog box."
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3154020.7
msgid  "Old Symbol Set"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3150209.8
msgid  "\<ahelp hid=\"STARMATH_COMBOBOX_RID_SYMDEFINEDIALOG_2\"\>This list box contains the name of the current symbol set. If you want, you can also select a different symbol set.\</ahelp\>"
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3145386.23
msgid  "Symbol"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3148870.25
msgid  "\<ahelp hid=\"STARMATH_COMBOBOX_RID_SYMDEFINEDIALOG_4\"\>Lists the names for the symbols in the current symbol set. Select a name from the list or type a name for a newly added symbol.\</ahelp\>"
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3150215.28
msgid  "Adding a New Symbol"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3143233.6
msgid  "To add a symbol to a symbol set, select a font in the \<emph\>Font\</emph\> box, and then click a symbol in symbols pane. In the \<emph\>Symbol\</emph\> box, type a name for the symbol. In the \<emph\>Symbol set\</emph\> list box, select a symbol set, or type a new name to create a new symbol set. The right preview pane displays the symbol that you selected. Click \<emph\>Add\</emph\> and then \<emph\>OK\</emph\>."
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3151389.29
msgid  "Modifying the Name of a Symbol"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3147296.21
msgid  "To change the name of a symbol, select the old name in the \<emph\>Old symbol\</emph\> list box. Then enter the new name in the \<emph\>Symbol\</emph\> box. Check whether the desired character is in the preview window before you click the \<emph\>Modify\</emph\> button. Click \<emph\>OK\</emph\>."
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3157870.24
msgid  "Symbol Set"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3145825.26
msgid  "\<ahelp hid=\"STARMATH_COMBOBOX_RID_SYMDEFINEDIALOG_5\"\>The \<emph\>Symbol set\</emph\> list box contains the names of all existing symbol sets. You can modify a symbol set or create a new one.\</ahelp\>"
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3154554.30
msgid  "Creating a New Symbol Set"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3145594.22
msgid  "To create a new symbol set, type a name for it in the \<emph\>Symbol set\</emph\> list box and add at least one symbol. Click \<emph\>OK\</emph\> to close the dialog. The new symbol set is now available under the new name."
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3153736.10
msgid  "Font"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3147374.11
msgid  "\<ahelp hid=\"STARMATH_LISTBOX_RID_SYMDEFINEDIALOG_1\"\>Displays the name of the current font and enables you to select a different font.\</ahelp\>"
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3150564.32
msgid  "Subset"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3145295.33
msgid  "\<ahelp hid=\"STARMATH_LISTBOX_RID_SYMDEFINEDIALOG_LB_FONTS_SUBSET\"\>If you selected a non-symbol font in the \<emph\>Font\</emph\> list box, you can select a Unicode subset in which to place your new or edited symbol. When a subset has been selected, all symbols belonging to this subset of the current symbol set are displayed in the symbols list above.\</ahelp\>"
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3148386.19
msgid  "Typeface"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3155366.20
msgid  "\<ahelp hid=\"STARMATH_COMBOBOX_RID_SYMDEFINEDIALOG_3\"\>The current typeface is displayed. You can change the typeface by selecting one from the list box.\</ahelp\>"
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3156262.12
msgid  "Add"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3153922.13
msgid  "\<ahelp hid=\"STARMATH_PUSHBUTTON_RID_SYMDEFINEDIALOG_1\"\>Click this button to add the symbol shown in the right preview window to the current symbol set.\</ahelp\> It will be saved under the name displayed in the \<emph\>Symbol\</emph\> list box. You must specify a name under \<emph\>Symbol\</emph\> or \<emph\>Symbol Set\</emph\> to be able to use this button. Names cannot be used more than once."
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3150756.14
msgid  "Modify"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3147570.15
msgid  "\<ahelp hid=\"STARMATH_PUSHBUTTON_RID_SYMDEFINEDIALOG_2\"\>Click this button to replace the name of the symbol shown in the left preview window (the old name is displayed in the \<emph\>Old symbol\</emph\> list box) with the new name you have entered in the \<emph\>Symbol\</emph\> list box.\</ahelp\>"
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3154640.31
msgid  "Moving a Symbol to Another Symbol Set"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3151174.27
msgid  "As an example, to transfer the large ALPHA from the \"Greek\" set to the \"Special\" set, select the old set (Greek) and then the ALPHA symbol using the two top list boxes. The symbol appears in the left preview window. In the \<emph\>Symbol set\</emph\> list box, select the \"Special\" set. Click \<emph\>Modify\</emph\> and then \<emph\>OK\</emph\>. The ALPHA symbol is now only in the \"Special\" symbol set."
msgstr ""

#: text/smath/01/06010100.xhp#hd_id3145414.16
msgid  "Delete"
msgstr ""

#: text/smath/01/06010100.xhp#par_id3154258.17
msgid  "\<ahelp hid=\"STARMATH_PUSHBUTTON_RID_SYMDEFINEDIALOG_3\"\>Click to remove the symbol shown in the left preview window from the current symbol set.\</ahelp\> There will be no security query. Deleting the last remaining symbol of a symbol set also deletes the symbol set."
msgstr ""

#: text/smath/01/06010100.xhp#par_id3153527.18
msgid  "You can also click \<emph\>Cancel\</emph\> at any time to close the dialog without saving any of the changes."
msgstr ""

#: text/smath/01/06020000.xhp#tit
msgid  "Import formula"
msgstr ""

#: text/smath/01/06020000.xhp#bm_id3154659
msgid  "\<bookmark_value\>importing; %PRODUCTNAME Math formulas\</bookmark_value\>"
msgstr ""

#: text/smath/01/06020000.xhp#hd_id3154659.1
msgid  "Import formula"
msgstr ""

#: text/smath/01/06020000.xhp#par_id3150251.2
msgid  "\<variable id=\"formelimportierentext\"\>\<ahelp hid=\"SID_INSERT_FORMULA\" visibility=\"visible\"\>This command opens a dialog for importing a formula.\</ahelp\>\</variable\>"
msgstr ""

#: text/smath/01/06020000.xhp#par_id3153916.3
msgid  "The \<emph\>Insert\</emph\> dialog is set up like the \<link href=\"text/shared/01/01020000.xhp\" name=\"Open\"\>Open\</link\> dialog under \<emph\>File\</emph\>. Use the \<emph\>Insert\</emph\> dialog to load, edit and display a formula saved as a file in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/02/03010000.xhp#tit
msgid  "Formula Cursor"
msgstr ""

#: text/smath/02/03010000.xhp#bm_id3149500
msgid  "\<bookmark_value\>formula cursor in $[officename] Math\</bookmark_value\>\<bookmark_value\>cursor; in $[officename] Math\</bookmark_value\>"
msgstr ""

#: text/smath/02/03010000.xhp#hd_id3149500.1
msgid  "Formula Cursor"
msgstr ""

#: text/smath/02/03010000.xhp#par_id3153916.2
msgid  "\<variable id=\"cursor\"\>\<ahelp hid=\"SID_FORMULACURSOR\"\>Use this icon on the Tools bar to turn the Formula Cursor on or off.\</ahelp\> The part of the formula where the cursor is positioned in the \<emph\>Commands\</emph\> window is marked with a thin border when the formula cursor is active.\</variable\>"
msgstr ""

#: text/smath/02/03010000.xhp#par_id3150048.14
msgid  "You can also click a position in the document to move the cursor to its corresponding position in the \<emph\>Commands\</emph\> window."
msgstr ""

#: text/smath/02/03010000.xhp#par_id3146966.15
msgid  "Double-clicking a character or symbol in the document moves the focus of the cursor to the \<emph\>Commands\</emph\> window and highlights its respective position. "
msgstr ""

#: text/smath/04/01020000.xhp#tit
msgid  "Formula Shortcut Keys"
msgstr ""

#: text/smath/04/01020000.xhp#bm_id3154702
msgid  "\<bookmark_value\>shortcut keys; in formulas\</bookmark_value\>"
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3154702.1
msgid  "\<variable id=\"math_keys\"\>\<link href=\"text/smath/04/01020000.xhp\" name=\"Formula Shortcut Keys\"\>Formula Shortcut Keys\</link\>\</variable\>"
msgstr ""

#: text/smath/04/01020000.xhp#par_id3150345.2
msgid  "A list of the shortcut keys specific to creating formulas is contained in this section."
msgstr ""

#: text/smath/04/01020000.xhp#par_id3150203.20
msgid  "The general \<link href=\"text/shared/04/01010000.xhp\" name=\"shortcut keys in $[officename]\"\>shortcut keys in $[officename]\</link\> also apply."
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3148870.3
msgid  "Shortcut Keys for Formula Functions"
msgstr ""

#: text/smath/04/01020000.xhp#par_id3153246.19
msgid  "The following shortcut keys correspond to commands in the \<emph\>Edit\</emph\> and \<emph\>View \</emph\>menus."
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3146324.11
msgid  "F3"
msgstr ""

#: text/smath/04/01020000.xhp#par_id3150537.12
msgid  "Next Error"
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3155620.13
msgid  "Shift+F3"
msgstr ""

#: text/smath/04/01020000.xhp#par_id3149355.14
msgid  "Previous Error"
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3153808.7
msgid  "F4"
msgstr ""

#: text/smath/04/01020000.xhp#par_id3149871.8
msgid  "Next Marker (Placeholder)"
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3150396.9
msgid  "Shift+F4"
msgstr ""

#: text/smath/04/01020000.xhp#par_id3151390.10
msgid  "Previous Marker (Placeholder)"
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3154554.17
msgid  "F9"
msgstr ""

#: text/smath/04/01020000.xhp#par_id3153003.18
msgid  "Update"
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3153732.21
msgid  "Navigation in the Elements Window"
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3155927.23
msgid  "Left or right arrow"
msgstr ""

#: text/smath/04/01020000.xhp#par_id3145249.24
msgid  "Move left or right to the next category or function."
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3150928.25
msgid  "Enter key"
msgstr ""

#: text/smath/04/01020000.xhp#par_id3148390.26
msgid  "Selects a category (within the category section) or inserts a function in the \<emph\>Commands\</emph\> window (within the function section)."
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3155988.27
msgid  "Tab"
msgstr ""

#: text/smath/04/01020000.xhp#par_id3153723.28
msgid  "Jump from the first category item to the first function of the category."
msgstr ""

#: text/smath/04/01020000.xhp#hd_id3083451.29
msgid  "Shift+Tab"
msgstr ""

#: text/smath/04/01020000.xhp#par_id3151181.30
msgid  "Jump from the last category item to the last function of the category."
msgstr ""

#: text/smath/guide/align.xhp#tit
msgid  "Manually Aligning Formula Parts"
msgstr ""

#: text/smath/guide/align.xhp#bm_id3156384
msgid  "\<bookmark_value\>aligning; characters in %PRODUCTNAME Math\</bookmark_value\>\<bookmark_value\>formula parts; manually aligning\</bookmark_value\>"
msgstr ""

#: text/smath/guide/align.xhp#hd_id3156384.1
msgid  "\<variable id=\"align\"\>\<link href=\"text/smath/guide/align.xhp\" name=\"Manually Aligning Formula Parts\"\>Manually Aligning Formula Parts\</link\>\</variable\>"
msgstr ""

#: text/smath/guide/align.xhp#hd_id3154657.2
msgid  "How do you align characters in $[officename] Math quickly and easily?"
msgstr ""

#: text/smath/guide/align.xhp#par_id3150249.3
msgid  "To accomplish this, you must define empty groups and character strings. They do not require any space, but carry information that helps in the alignment process."
msgstr ""

#: text/smath/guide/align.xhp#par_id3153912.4
msgid  "To create empty groups, enter curly brackets \<emph\>{}\</emph\> in the Commands window. In the following example, the goal is to achieve a line break so that the plus signs are beneath one another, even though one less character is entered in the upper line:"
msgstr ""

#: text/smath/guide/align.xhp#par_id3153246.7
msgid  "a+a+a+{} newline {}{}{}{}{}a+a+a+a"
msgstr ""

#: text/smath/guide/align.xhp#par_id3143229.5
msgid  "Empty character strings are a simple way to ensure that texts and formulas are left-aligned. They are defined using double inverted commas \"\" . Make sure you do not use any typographic inverted commas. Example:"
msgstr ""

#: text/smath/guide/align.xhp#par_id3153809.6
msgid  "\"A further example.\" newline a+b newline \"\"c-d"
msgstr ""

#: text/smath/guide/attributes.xhp#tit
msgid  "Changing Default Attributes"
msgstr ""

#: text/smath/guide/attributes.xhp#bm_id3145792
msgid  "\<bookmark_value\>attributes; changing in $[officename] Math\</bookmark_value\>\<bookmark_value\>font attributes;changing defaults\</bookmark_value\>\<bookmark_value\>formatting;changing default attributes\</bookmark_value\>\<bookmark_value\>defaults;changing default formatting\</bookmark_value\>\<bookmark_value\>changing;default formatting\</bookmark_value\>"
msgstr ""

#: text/smath/guide/attributes.xhp#hd_id3145792.1
msgid  "\<variable id=\"attributes\"\>\<link href=\"text/smath/guide/attributes.xhp\" name=\"Changing Default Attributes\"\>Changing Default Attributes\</link\>\</variable\>"
msgstr ""

#: text/smath/guide/attributes.xhp#hd_id3154484.2
msgid  "Can default formats in $[officename] Math be modified?"
msgstr ""

#: text/smath/guide/attributes.xhp#par_id3148870.3
msgid  "Some parts of formulas are always formatted bold or italic by default."
msgstr ""

#: text/smath/guide/attributes.xhp#par_id3150210.7
msgid  "You can remove these attributes using \"nbold\" and \"nitalic\". Example:"
msgstr ""

#: text/smath/guide/attributes.xhp#par_id3143231.6
msgid  "a + b"
msgstr ""

#: text/smath/guide/attributes.xhp#par_id3153810.5
msgid  "nitalic a + bold b."
msgstr ""

#: text/smath/guide/attributes.xhp#par_id3149872.4
msgid  "In the second formula, the a is not italic. The b is bold. You cannot change the plus sign by this method."
msgstr ""

#: text/smath/guide/brackets.xhp#tit
msgid  "Merging Formula Parts in Brackets"
msgstr ""

#: text/smath/guide/brackets.xhp#bm_id3152596
msgid  "\<bookmark_value\>brackets; merging formula parts\</bookmark_value\>\<bookmark_value\>formula parts; merging\</bookmark_value\>\<bookmark_value\>fractions in formulas\</bookmark_value\>\<bookmark_value\>merging;formula parts\</bookmark_value\>"
msgstr ""

#: text/smath/guide/brackets.xhp#hd_id3152596.1
msgid  "\<variable id=\"brackets\"\>\<link href=\"text/smath/guide/brackets.xhp\" name=\"Merging Formula Parts in Brackets\"\>Merging Formula Parts in Brackets\</link\>\</variable\>"
msgstr ""

#: text/smath/guide/brackets.xhp#hd_id3154511.2
msgid  "Inserting fractions into formulas"
msgstr ""

#: text/smath/guide/brackets.xhp#par_id3146971.4
msgid  "In the case of a fraction whose numerator and denominator consist of a product, a sum, and so on, the values that belong together must be bracketed together."
msgstr ""

#: text/smath/guide/brackets.xhp#par_id3149021.3
msgid  "Use the following syntax:"
msgstr ""

#: text/smath/guide/brackets.xhp#par_id3083280.7
msgid  "{a + c} over 2 = m"
msgstr ""

#: text/smath/guide/brackets.xhp#par_id3154703.6
msgid  "or"
msgstr ""

#: text/smath/guide/brackets.xhp#par_id3150297.5
msgid  "m = {a + c} over 2"
msgstr ""

#: text/smath/guide/comment.xhp#tit
msgid  "Entering Comments"
msgstr ""

#: text/smath/guide/comment.xhp#bm_id3155961
msgid  "\<bookmark_value\>comments; entering in $[officename] Math\</bookmark_value\>\<bookmark_value\>inserting;comments in $[officename] Math\</bookmark_value\>"
msgstr ""

#: text/smath/guide/comment.xhp#hd_id3155961.1
msgid  "\<variable id=\"comment\"\>\<link href=\"text/smath/guide/comment.xhp\" name=\"Entering Comments\"\>Entering Comments\</link\>\</variable\>"
msgstr ""

#: text/smath/guide/comment.xhp#hd_id3154657.2
msgid  "How does one attach comments that don't appear in the document to a formula?"
msgstr ""

#: text/smath/guide/comment.xhp#par_id3149499.3
msgid  "A comment begins with a double percent sign \<emph\>%%\</emph\>, and extends to the next line-end character (Enter key). Everything that lies in between is ignored and is not printed out. If there are percent signs in the text, they are treated as part of the text."
msgstr ""

#: text/smath/guide/comment.xhp#par_idN105D0
msgid  "Example:"
msgstr ""

#: text/smath/guide/comment.xhp#par_idN105D3
msgid  "a^2+b^2=c^2 %% Pythagorean theorem."
msgstr ""

#: text/smath/guide/keyboard.xhp#tit
msgid  "Shortcuts ($[officename] Math Accessibility)"
msgstr ""

#: text/smath/guide/keyboard.xhp#bm_id3149018
msgid  "\<bookmark_value\>accessibility; $[officename] Math shortcuts\</bookmark_value\>"
msgstr ""

#: text/smath/guide/keyboard.xhp#hd_id3149018.12
msgid  "\<variable id=\"keyboard\"\>\<link href=\"text/smath/guide/keyboard.xhp\" name=\"Shortcuts ($[officename] Math Accessibility)\"\>Shortcuts ($[officename] Math Accessibility)\</link\>\</variable\>"
msgstr ""

#: text/smath/guide/keyboard.xhp#par_id3150298.1
msgid  "You can control $[officename] Math without a mouse."
msgstr ""

#: text/smath/guide/keyboard.xhp#hd_id3150343.2
msgid  "Inserting a Formula Directly"
msgstr ""

#: text/smath/guide/keyboard.xhp#par_id3154659.3
msgid  "If you want to insert a formula into a text document, and you already know the correct writing, you can proceed as follows:"
msgstr ""

#: text/smath/guide/keyboard.xhp#par_id3153818.4
msgid  "Write the formula into your text"
msgstr ""

#: text/smath/guide/keyboard.xhp#par_id3153915.5
msgid  "Select the formula"
msgstr ""

#: text/smath/guide/keyboard.xhp#par_id3150213.6
msgid  "Choose the command \<emph\>Insert - Object - Formula\</emph\>."
msgstr ""

#: text/smath/guide/keyboard.xhp#hd_id3154767.7
msgid  "Inserting a Formula using a Window"
msgstr ""

#: text/smath/guide/keyboard.xhp#par_id3149875.8
msgid  "If you want to use the $[officename] Math interface to edit a formula, choose the command \<emph\>Insert - Object - Formula\</emph\> without any text selected."
msgstr ""

#: text/smath/guide/keyboard.xhp#par_id3150391.9
msgid  "The cursor waits in the Commands window and you can type the formula."
msgstr ""

#: text/smath/guide/keyboard.xhp#par_id3150537.13
msgid  "You can compose formulas using the Elements window. Open it with the menu \<emph\>View - Elements\</emph\> if it is not already open."
msgstr ""

#: text/smath/guide/keyboard.xhp#par_id3155625.10
msgid  "If the Elements window is open, use F6 to switch from the Commands window to the Elements window and back."
msgstr ""

#: text/smath/guide/keyboard.xhp#hd_id3154554.11
msgid  "Elements window"
msgstr ""

#: text/smath/guide/limits.xhp#tit
msgid  "Working with Limits"
msgstr ""

#: text/smath/guide/limits.xhp#bm_id8404492
msgid  "\<bookmark_value\>limits;in sums/integrals\</bookmark_value\>\<bookmark_value\>integral limits\</bookmark_value\>"
msgstr ""

#: text/smath/guide/limits.xhp#hd_id1892147
msgid  "\<variable id=\"limits\"\>\<link href=\"text/smath/guide/limits.xhp\"\>Working with Limits\</link\>\</variable\>"
msgstr ""

#: text/smath/guide/limits.xhp#hd_id9881893
msgid  "How can I define the limits in a Sum or Integral formula?"
msgstr ""

#: text/smath/guide/limits.xhp#par_id6504409
msgid  "You want to insert a summation formula like \"summation of s^k from k = 0 to n\" at the cursor in a Writer text document."
msgstr ""

#: text/smath/guide/limits.xhp#par_id8811304
msgid  "Choose \<item type=\"menuitem\"\>Insert - Object - Formula\</item\>."
msgstr ""

#: text/smath/guide/limits.xhp#par_id1276589
msgid  "You see the Math input window and the Elements window. If you don't see the Elements window, you can enable it in the View menu."
msgstr ""

#: text/smath/guide/limits.xhp#par_id3283791
msgid  "In the upper part of the Elements window, click the \<emph\>Operators\</emph\> icon."
msgstr ""

#: text/smath/guide/limits.xhp#par_id9734794
msgid  "In the lower part of the Elements window, click the \<emph\>Sum\</emph\> icon."
msgstr ""

#: text/smath/guide/limits.xhp#par_id9641712
msgid  "To enable lower and upper limits, click additionally the \<emph\>Upper and Lower Limits\</emph\> icon."
msgstr ""

#: text/smath/guide/limits.xhp#par_id3304239
msgid  "In the input window, the first placeholder or marker is selected, and you can start to enter the lower limit: "
msgstr ""

#: text/smath/guide/limits.xhp#par_id8679158
msgid  "k = 0"
msgstr ""

#: text/smath/guide/limits.xhp#par_id8471327
msgid  "Press F4 to advance to the next marker, and enter the upper limit:"
msgstr ""

#: text/smath/guide/limits.xhp#par_id4731894
msgid  "n"
msgstr ""

#: text/smath/guide/limits.xhp#par_id759300
msgid  "Press F4 to advance to the next marker, and enter the summand:"
msgstr ""

#: text/smath/guide/limits.xhp#par_id651875
msgid  "s^k"
msgstr ""

#: text/smath/guide/limits.xhp#par_id6756187
msgid  "Now the formula is complete. Click into your text document outside the formula to leave the formula editor."
msgstr ""

#: text/smath/guide/limits.xhp#par_id9406414
msgid  "In the same way, you can enter an Integral formula with limits. When you click an icon from the Elements window, the assigned text command is inserted in the input window. If you know the text commands, you can enter the commands directly in the input window."
msgstr ""

#: text/smath/guide/limits.xhp#par_id5866267
msgid  "Choose \<item type=\"menuitem\"\>Insert - Object - Formula\</item\>."
msgstr ""

#: text/smath/guide/limits.xhp#par_id1965697
msgid  "Click in the input window and enter the following line:"
msgstr ""

#: text/smath/guide/limits.xhp#par_id9004486
msgid  "int from{a} to{b} f(x)`dx"
msgstr ""

#: text/smath/guide/limits.xhp#par_id4651020
msgid  "A small gap exists between f(x) and dx, which you can also enter using the Elements window: click the \<emph\>Format\</emph\> icon, then the \<emph\>Small Gap\</emph\> icon."
msgstr ""

#: text/smath/guide/limits.xhp#par_id3877071
msgid  "If you don't like the font of the letters f and x, choose \<item type=\"menuitem\"\>Format - Fonts\</item\> and select other fonts. Click the \<emph\>Default\</emph\> button to use the new fonts as default from now on."
msgstr ""

#: text/smath/guide/limits.xhp#par_id3021332
msgid  "If you need the formula within a line of text, the limits increase the line height. You can choose \<item type=\"menuitem\"\>Format - Text Mode\</item\> to place the limits besides the Sum or Integral symbol, which reduces the line height."
msgstr ""

#: text/smath/guide/limits.xhp#par_id260322
msgid  "\<link href=\"text/smath/01/03090909.xhp\"\>Example of Integral and Sum ranges\</link\>"
msgstr ""

#: text/smath/guide/main.xhp#tit
msgid  "Instructions for Using $[officename] Math"
msgstr ""

#: text/smath/guide/main.xhp#bm_id3147341
msgid  "\<bookmark_value\>$[officename] Math;general instructions\</bookmark_value\>\<bookmark_value\>instructions; $[officename] Math\</bookmark_value\>\<bookmark_value\>Equation Editor, see $[officename] Math\</bookmark_value\>"
msgstr ""

#: text/smath/guide/main.xhp#hd_id3147341.1
msgid  "\<variable id=\"main\"\>\<link href=\"text/smath/guide/main.xhp\" name=\"Instructions for Using $[officename] Math\"\>Instructions for Using $[officename] Math\</link\>\</variable\>"
msgstr ""

#: text/smath/guide/main.xhp#hd_id3150199.2
msgid  "Entering and Editing Formulas"
msgstr ""

#: text/smath/guide/newline.xhp#tit
msgid  "Entering Line Breaks"
msgstr ""

#: text/smath/guide/newline.xhp#bm_id1295205
msgid  "\<bookmark_value\>line breaks; in formulas\</bookmark_value\>\<bookmark_value\>formulas;line breaks\</bookmark_value\>\<bookmark_value\>wrapping text;in formulas\</bookmark_value\>"
msgstr ""

#: text/smath/guide/newline.xhp#hd_id3146970.1
msgid  "\<variable id=\"newline\"\>\<link href=\"text/smath/guide/newline.xhp\" name=\"Entering Line Breaks\"\>Entering Line Breaks\</link\>\</variable\>"
msgstr ""

#: text/smath/guide/newline.xhp#hd_id3147339.2
msgid  "How to write formulas in $[officename] Math over two lines (with manual line break):"
msgstr ""

#: text/smath/guide/newline.xhp#par_id3154702.3
msgid  "Create a line break by using the \"newline\" command. Everything coming after the line break is placed on the next line."
msgstr ""

#: text/smath/guide/parentheses.xhp#tit
msgid  "Inserting Brackets"
msgstr ""

#: text/smath/guide/parentheses.xhp#bm_id3153415
msgid  "\<bookmark_value\>brackets; inserting in %PRODUCTNAME Math\</bookmark_value\>\<bookmark_value\>inserting;brackets\</bookmark_value\>\<bookmark_value\>distances between brackets\</bookmark_value\>"
msgstr ""

#: text/smath/guide/parentheses.xhp#hd_id3153415.1
msgid  "\<variable id=\"parentheses\"\>\<link href=\"text/smath/guide/parentheses.xhp\" name=\"Inserting Brackets\"\>Inserting Brackets\</link\>\</variable\>"
msgstr ""

#: text/smath/guide/parentheses.xhp#hd_id3150751.2
msgid  "In \<item type=\"productname\"\>%PRODUCTNAME\</item\> Math, can brackets be shown separately so that the distance between them is freely definable?"
msgstr ""

#: text/smath/guide/parentheses.xhp#par_id3083281.3
msgid  "You can set individual brackets using \"left\" and \"right\", but the distance between the brackets will not be fixed, as they adapt to the argument. Nevertheless, there is a way to display brackets so that the distance between them is fixed. To accomplish this, place a \"\\\\\" (backslash) before the normal brackets. These brackets now behave like any other symbol and the alignment is the same as with other symbols:"
msgstr ""

#: text/smath/guide/parentheses.xhp#par_id3155960.6
msgid  "left lbrace x right none"
msgstr ""

#: text/smath/guide/parentheses.xhp#par_id3148489.5
msgid  "size *2 langle x rangle"
msgstr ""

#: text/smath/guide/parentheses.xhp#par_id3150344.4
msgid  "size *2 \\\\langle x \\\\rangle"
msgstr ""

#: text/smath/guide/text.xhp#tit
msgid  "Entering Text"
msgstr ""

#: text/smath/guide/text.xhp#bm_id3155962
msgid  "\<bookmark_value\>text strings; entering in $[officename] Math\</bookmark_value\>\<bookmark_value\>direct text; entering in $[officename] Math\</bookmark_value\>\<bookmark_value\>inserting;text in $[officename] Math\</bookmark_value\>"
msgstr ""

#: text/smath/guide/text.xhp#hd_id5676442
msgid  "\<variable id=\"text\"\>\<link href=\"text/smath/guide/text.xhp\" name=\"Entering Text\"\>Entering Text\</link\>\</variable\>"
msgstr ""

#: text/smath/guide/text.xhp#hd_id8509170
msgid  "How to enter direct text strings that do not get interpreted?"
msgstr ""

#: text/smath/guide/text.xhp#par_id337229
msgid  "Some text strings get interpreted as operators automatically. Sometimes this is not what you want. If you want to write W\<emph\>*\</emph\> (a letter with a superscripted asterisk), the asterisk will be interpreted as a multiplication operator. Enclose the direct text within double quotes or add spaceholders."
msgstr ""

#: text/smath/guide/text.xhp#par_idN105D0
msgid  "Examples:"
msgstr ""

#: text/smath/guide/text.xhp#par_id521866
msgid  "An imported MathType formula contains the following string"
msgstr ""

#: text/smath/guide/text.xhp#par_id9413739
msgid  "W rSup { size 8{*} }"
msgstr ""

#: text/smath/guide/text.xhp#par_id755943
msgid  "If you have set up Math to convert imported MathType formulas (in \<switchinline select=\"sys\"\>\<caseinline select=\"MAC\"\>%PRODUCTNAME - Preferences\</caseinline\>\<defaultinline\>Tools - Options\</defaultinline\>\</switchinline\> - Load/Save - Microsoft Office), you see the formula with a placeholder instead of the asterisk."
msgstr ""

#: text/smath/guide/text.xhp#par_id5988952
msgid  "Change {*} to {} * {} as in the following formula:"
msgstr ""

#: text/smath/guide/text.xhp#par_id3304544
msgid  "W rSup { size 8{} * {} }"
msgstr ""

#: text/smath/guide/text.xhp#par_id4941557
msgid  "You can also use W^\"*\" to enter the character as direct text."
msgstr ""

#: text/smath/guide/text.xhp#par_id9961851
msgid  "Some formulas start with an = sign. Use \"=\" to enter that character as direct text."
msgstr ""

#: text/smath/main0000.xhp#tit
msgid  "Welcome to the $[officename] Math Help"
msgstr ""

#: text/smath/main0000.xhp#hd_id3148868.1
msgid  "Welcome to the $[officename] Math Help"
msgstr ""

#: text/smath/main0000.xhp#hd_id3153915.5
msgid  "How to Work With $[officename] Math"
msgstr ""

#: text/smath/main0000.xhp#par_id3143229.6
msgid  "\<link href=\"text/smath/01/03091500.xhp\" name=\"Formula Reference Tables\"\>Formula Reference Tables\</link\>"
msgstr ""

#: text/smath/main0000.xhp#hd_id3153808.8
msgid  "$[officename] Math Menus, Toolbars, and Keys"
msgstr ""

#: text/smath/main0000.xhp#par_id3143269
msgid  "Have a look at \<link href=\"http://www.dmaths.org\"\>www.dmaths.org\</link\> for a set of additional %PRODUCTNAME Math icons and macros."
msgstr ""

#: text/smath/main0000.xhp#hd_id3156396.7
msgid  "Help about the Help"
msgstr ""

#: text/smath/main0100.xhp#tit
msgid  "Menus"
msgstr ""

#: text/smath/main0100.xhp#hd_id3149021.1
msgid  "\<variable id=\"main0100\"\>\<link href=\"text/smath/main0100.xhp\" name=\"Menus\"\>Menus\</link\>\</variable\>"
msgstr ""

#: text/smath/main0100.xhp#par_id3154702.2
msgid  "The menu bar contains all the commands for working with $[officename] Math. It contains a list of all the available operators as well as the commands for editing, viewing, arranging, formatting and printing formula documents and the objects contained in them. Most of the menu commands are only available when you are creating or editing a formula."
msgstr ""

#: text/smath/main0101.xhp#tit
msgid  "File"
msgstr ""

#: text/smath/main0101.xhp#hd_id3149018.1
msgid  "\<link href=\"text/smath/main0101.xhp\" name=\"File\"\>File\</link\>"
msgstr ""

#: text/smath/main0101.xhp#par_id3155959.2
msgid  "This menu contains the general commands for working with formula documents, such as open, save and print."
msgstr ""

#: text/smath/main0101.xhp#hd_id3148489.3
msgid  "\<link href=\"text/shared/01/01020000.xhp\" name=\"Open\"\>Open\</link\>"
msgstr ""

#: text/smath/main0101.xhp#hd_id3149501.10
msgid  "\<link href=\"text/shared/autopi/01000000.xhp\" name=\"AutoPilot\"\>Wizards\</link\>"
msgstr ""

#: text/smath/main0101.xhp#par_id3148840.11
msgid  "Use a Wizard to create interactive documents, such as professional letters and faxes, into which you can insert your saved formulas."
msgstr ""

#: text/smath/main0101.xhp#hd_id3153251.4
msgid  "\<link href=\"text/shared/01/01070000.xhp\" name=\"Save As\"\>Save As\</link\>"
msgstr ""

#: text/smath/main0101.xhp#hd_id3149871.12
msgid  "\<link href=\"text/shared/01/01190000.xhp\" name=\"Versions\"\>Versions\</link\>"
msgstr ""

#: text/smath/main0101.xhp#hd_id3146325.6
msgid  "\<link href=\"text/shared/01/01100000.xhp\" name=\"Properties\"\>Properties\</link\>"
msgstr ""

#: text/smath/main0101.xhp#hd_id3155621.7
msgid  "\<link href=\"text/shared/01/01130000.xhp\" name=\"Print\"\>Print\</link\>"
msgstr ""

#: text/smath/main0101.xhp#hd_id3145826.8
msgid  "\<link href=\"text/shared/01/01140000.xhp\" name=\"Printer Setup\"\>Printer Setup\</link\>"
msgstr ""

#: text/smath/main0102.xhp#tit
msgid  "Edit"
msgstr ""

#: text/smath/main0102.xhp#hd_id3156385.1
msgid  "\<link href=\"text/smath/main0102.xhp\" name=\"Edit\"\>Edit\</link\>"
msgstr ""

#: text/smath/main0102.xhp#par_id3145790.2
msgid  "The commands in this menu are used to edit formulas. In addition to basic commands, (for example, copying contents) there are functions specific to $[officename] Math such as searching for placeholders or errors."
msgstr ""

#: text/smath/main0103.xhp#tit
msgid  "View"
msgstr ""

#: text/smath/main0103.xhp#hd_id3155064.1
msgid  "\<link href=\"text/smath/main0103.xhp\" name=\"View\"\>View\</link\>"
msgstr ""

#: text/smath/main0103.xhp#par_id3147338.2
msgid  "Sets the display scale and defines which elements you want to be visible. Most of the commands that you can enter into the \<emph\>Commands\</emph\> window can also be accessed through a mouse click if you have already opened the Elements window with \<link href=\"text/smath/01/03090000.xhp\" name=\"View - Elements\"\>\<emph\>View - Elements\</emph\>\</link\>."
msgstr ""

#: text/smath/main0103.xhp#hd_id3150205.5
msgid  "\<link href=\"text/shared/01/03010000.xhp\" name=\"Zoom\"\>Zoom\</link\>"
msgstr ""

#: text/smath/main0105.xhp#tit
msgid  "Format"
msgstr ""

#: text/smath/main0105.xhp#hd_id3149121.1
msgid  "\<link href=\"text/smath/main0105.xhp\" name=\"Format\"\>Format\</link\>"
msgstr ""

#: text/smath/main0105.xhp#par_id3149018.2
msgid  "This menu contains commands needed to format formulas."
msgstr ""

#: text/smath/main0105.xhp#hd_id3156385.3
msgid  "\<link href=\"text/smath/01/05010000.xhp\" name=\"Fonts\"\>Fonts\</link\>"
msgstr ""

#: text/smath/main0105.xhp#hd_id3154656.4
msgid  "\<link href=\"text/smath/01/05020000.xhp\" name=\"Font Size\"\>Font Size\</link\>"
msgstr ""

#: text/smath/main0105.xhp#hd_id3154484.5
msgid  "\<link href=\"text/smath/01/05030000.xhp\" name=\"Spacing\"\>Spacing\</link\>"
msgstr ""

#: text/smath/main0105.xhp#hd_id3151242.6
msgid  "\<link href=\"text/smath/01/05040000.xhp\" name=\"Alignment\"\>Alignment\</link\>"
msgstr ""

#: text/smath/main0106.xhp#tit
msgid  "Tools"
msgstr ""

#: text/smath/main0106.xhp#hd_id3149019.1
msgid  "\<link href=\"text/smath/main0106.xhp\" name=\"Tools\"\>Tools\</link\>"
msgstr ""

#: text/smath/main0106.xhp#par_id3155959.2
msgid  "Use this menu to open and edit the symbol catalog, or import an external formula as a data file. The program interface can be adjusted to meet your requirements. You can also change the program options."
msgstr ""

#: text/smath/main0106.xhp#hd_id3150206.4
msgid  "\<link href=\"text/smath/01/06020000.xhp\" name=\"Import Formula\"\>Import Formula\</link\>"
msgstr ""

#: text/smath/main0106.xhp#hd_id3145385.5
msgid  "\<link href=\"text/shared/01/06140000.xhp\" name=\"Customize\"\>Customize\</link\>"
msgstr ""

#: text/smath/main0107.xhp#tit
msgid  "Window"
msgstr ""

#: text/smath/main0107.xhp#hd_id3155066.1
msgid  "\<link href=\"text/smath/main0107.xhp\" name=\"Window\"\>Window\</link\>"
msgstr ""

#: text/smath/main0107.xhp#par_id3147339.2
msgid  "In the Window menu, you can open a new window and see the document list."
msgstr ""

#: text/smath/main0200.xhp#tit
msgid  "Toolbars"
msgstr ""

#: text/smath/main0200.xhp#hd_id3149121.1
msgid  "\<variable id=\"main0200\"\>\<link href=\"text/smath/main0200.xhp\" name=\"Toolbars\"\>Toolbars\</link\>\</variable\>"
msgstr ""

#: text/smath/main0200.xhp#par_id3147338.2
msgid  "The default toolbars available when working with an activated formula document in $[officename] Math are described here. You can customize the toolbars to meet your requirements by moving, deleting or adding new icons."
msgstr ""

#: text/smath/main0202.xhp#tit
msgid  "Status Bar"
msgstr ""

#: text/smath/main0202.xhp#hd_id3150749.1
msgid  "\<link href=\"text/smath/main0202.xhp\" name=\"Status Bar\"\>Status Bar\</link\>"
msgstr ""

#: text/smath/main0202.xhp#par_id3083278.2
msgid  "The status bar displays information about the active document."
msgstr ""

#: text/smath/main0203.xhp#tit
msgid  "Tools Bar"
msgstr ""

#: text/smath/main0203.xhp#hd_id3149123.1
msgid  "\<link href=\"text/smath/main0203.xhp\" name=\"Tools Bar\"\>Tools Bar\</link\>"
msgstr ""

#: text/smath/main0203.xhp#par_id3147338.2
msgid  "The Tools bar contains frequently used functions."
msgstr ""

#: text/smath/main0203.xhp#hd_id3151242.3
msgid  "\<link href=\"text/smath/02/03010000.xhp\" name=\"Formula Cursor\"\>Formula Cursor\</link\>"
msgstr ""

#: text/smath/main0503.xhp#tit
msgid  "$[officename] Math Features"
msgstr ""

#: text/smath/main0503.xhp#hd_id3155064.1
msgid  "\<variable id=\"main0503\"\>\<link href=\"text/smath/main0503.xhp\" name=\"$[officename] Math Features\"\>$[officename] Math Features\</link\>\</variable\>"
msgstr ""

#: text/smath/main0503.xhp#par_id3156386.2
msgid  "This section contains an overview of some of the important functions and capabilities that $[officename] Math offers."
msgstr ""

#: text/smath/main0503.xhp#par_id3148486.3
msgid  "$[officename] Math provides numerous operators, functions and formatting assistants to help you create formulas. These are all listed in a selection window, in which you can click the required element with the mouse to insert the object into your work. There is an exhaustive \<link href=\"text/smath/01/03091500.xhp\" name=\"reference\"\>reference\</link\> list and numerous \<link href=\"text/smath/01/03090900.xhp\" name=\"samples\"\>samples\</link\> contained in the Help."
msgstr ""

#: text/smath/main0503.xhp#hd_id3150207.10
msgid  "Creating a Formula"
msgstr ""

#: text/smath/main0503.xhp#par_id3145386.12
msgid  "As with charts and images, formulas are created as objects within a document. Inserting a formula into a document automatically starts $[officename] Math. You can create, edit and format the formula using a large selection of predefined symbols and functions."
msgstr ""

#: text/smath/main0503.xhp#hd_id3153916.15
msgid  "Typing a Formula Directly"
msgstr ""

#: text/smath/main0503.xhp#par_id3150213.13
msgid  "If you are familiar with the $[officename] Math language, you can also type a formula directly into the document. For example, type this formula into a text document: \"a sup 2 + b sup 2 = c sup 2\". Select this text and choose \<emph\>Insert - Object - Formula\</emph\>. The text will be converted into a formatted formula."
msgstr ""

#: text/smath/main0503.xhp#par_id3146325.14
msgid  "Formulas cannot be calculated in $[officename] Math because it is a formula editor (for writing and showing formulas) and not a calculation program. Use spreadsheets to calculate formulas, or for simple calculations use the text document calculation function."
msgstr ""

#: text/smath/main0503.xhp#hd_id3145829.16
msgid  "Creating a Formula in the Commands Window"
msgstr ""

#: text/smath/main0503.xhp#par_id3153001.4
msgid  "\<ahelp hid=\"HID_SMA_COMMAND_WIN_EDIT\"\>Use the $[officename] Math Commands window to enter and edit formulas. As you make entries in the Commands window, you see the results in the document.\</ahelp\> To maintain an overview when creating long and complicated formulas, use the Formula Cursor on the Tools bar. When this function is activated, the cursor location within the Commands window is also shown in the text window."
msgstr ""

#: text/smath/main0503.xhp#hd_id3150014.17
msgid  "Individual Symbols"
msgstr ""

#: text/smath/main0503.xhp#par_id3145246.6
msgid  "You can create your own symbols and import characters from other fonts. You can add new symbols to the basic catalog of $[officename] Math symbols, or create your own special catalogs. Numerous special characters are also available."
msgstr ""

#: text/smath/main0503.xhp#hd_id3148392.18
msgid  "Formulas in Context"
msgstr ""

#: text/smath/main0503.xhp#par_id3148774.8
msgid  "To make working with formulas easier, use the context menus, which can be called up with a right mouse click. This applies especially to the Commands window. This context menu contains all the commands that are found in the Elements window, and also operators, and so on, which can be inserted into your formula by mouse-click without having to key them into the Commands window."
msgstr ""

#: smath.tree#03
msgid  "Formulas"
msgstr ""

#: smath.tree#0301
msgid  "General Information and User Interface Usage"
msgstr ""

#: smath.tree#smath/text/smath/main0000.xhp
msgid  "Welcome to the %PRODUCTNAME Math Help"
msgstr ""

#: smath.tree#smath/text/smath/main0503.xhp
msgid  "%PRODUCTNAME Math Features"
msgstr ""

#: smath.tree#smath/text/smath/guide/main.xhp
msgid  "Instructions for Using %PRODUCTNAME Math"
msgstr ""

#: smath.tree#smath/text/smath/guide/keyboard.xhp
msgid  "Shortcuts (%PRODUCTNAME Math Accessibility)"
msgstr ""

#: smath.tree#0302
msgid  "Command and Menu Reference"
msgstr ""

#: smath.tree#smath/text/smath/main0100.xhp
msgid  "Menus"
msgstr ""

#: smath.tree#smath/text/smath/main0200.xhp
msgid  "Toolbars"
msgstr ""

#: smath.tree#0303
msgid  "Working with Formulas"
msgstr ""

#: smath.tree#smath/text/smath/guide/align.xhp
msgid  "Manually Aligning Formula Parts"
msgstr ""

#: smath.tree#smath/text/smath/guide/attributes.xhp
msgid  "Changing Default Attributes"
msgstr ""

#: smath.tree#smath/text/smath/guide/brackets.xhp
msgid  "Merging Formula Parts in Brackets"
msgstr ""

#: smath.tree#smath/text/smath/guide/comment.xhp
msgid  "Entering Comments"
msgstr ""

#: smath.tree#smath/text/smath/guide/newline.xhp
msgid  "Entering Line Breaks"
msgstr ""

#: smath.tree#smath/text/smath/guide/parentheses.xhp
msgid  "Inserting Brackets"
msgstr ""
