<?xml version="1.0" encoding="UTF-8"?>
<helpdocument version="1.0">
	
<!--***********************************************************
 * 
 * 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.
 * 
 ***********************************************************-->



	
<meta>
<topic id="textscalc0104060184xml" indexer="include">
<title xml-lang="en-US" id="tit">Statistical Functions Part Four</title>
<filename>/text/scalc/01/04060184.xhp</filename>
</topic>
</meta>
<body>
<paragraph xml-lang="en-US" id="hd_id3153415" role="heading" level="1" l10n="U" oldref="1"><variable id="mq"><link href="text/scalc/01/04060184.xhp" name="Statistical Functions Part Four">Statistical Functions Part Four</link>
</variable></paragraph>
<sort order="asc">
<section id="max">
<bookmark xml-lang="en-US" branch="index" id="bm_id3154511"><bookmark_value>MAX function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_MAX" id="bm_id3146972" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3154511" role="heading" level="2" l10n="U" oldref="2">MAX</paragraph>
<paragraph xml-lang="en-US" id="par_id3153709" role="paragraph" l10n="U" oldref="3"><ahelp hid="HID_FUNC_MAX">Returns the maximum value in a list of arguments.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="par_id9282509" role="paragraph" l10n="NEW">Returns 0 if no numeric value and no error was encountered in the cell range(s) passed as cell reference(s). Text cells are ignored by MIN() and MAX(). The functions MINA() and MAXA() return 0 if no value (numeric or text) and no error was encountered. Passing a literal string argument to MIN() or MAX(), e.g. MIN("string"), still results in an error.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3154256" role="heading" level="3" l10n="U" oldref="4">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3147340" role="code" l10n="U" oldref="5">MAX(Number1; Number2; ...Number30)</paragraph>
<paragraph xml-lang="en-US" id="par_id3149568" role="paragraph" l10n="CHG" oldref="6"><emph>Number1; Number2;...Number30</emph> are numerical values or ranges. </paragraph>
<paragraph xml-lang="en-US" id="hd_id3153963" role="heading" level="3" l10n="U" oldref="7">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3147343" role="paragraph" l10n="U" oldref="8">
<item type="input">=MAX(A1;A2;A3;50;100;200)</item> returns the largest value from the list.</paragraph>
<paragraph xml-lang="en-US" id="par_id3148485" role="paragraph" l10n="U" oldref="9">
<item type="input">=MAX(A1:B100)</item> returns the largest value from the list.</paragraph>
</section>
<section id="maxa">
<bookmark xml-lang="en-US" branch="index" id="bm_id3166426"><bookmark_value>MAXA function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_MAXA" id="bm_id3150304" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3166426" role="heading" level="2" l10n="U"
oldref="139">MAXA</paragraph>
<paragraph xml-lang="en-US" id="par_id3150363" role="paragraph" l10n="U" oldref="140"><ahelp hid="HID_FUNC_MAXA">Returns the maximum value in a list of arguments. In opposite to MAX, here you can enter text. The value of the text is 0.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="par_id7689443" role="paragraph" l10n="NEW">The functions MINA() and MAXA() return 0 if no value (numeric or text) and no error was encountered.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3150516" role="heading" level="3" l10n="U"
oldref="141">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3166431" role="code" l10n="U" oldref="142">MAXA(Value1; Value2; ... Value30)</paragraph>
<paragraph xml-lang="en-US" id="par_id3150202" role="paragraph" l10n="CHG" oldref="143"><emph>Value1; Value2;...Value30</emph> are values or ranges. Text has the value of 0.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3156290" role="heading" level="3" l10n="U"
oldref="144">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3156446" role="paragraph" l10n="CHG" oldref="145">
<item type="input">=MAXA(A1;A2;A3;50;100;200;"Text")</item> returns the largest value from the list.</paragraph>
<paragraph xml-lang="en-US" id="par_id3149404" role="paragraph" l10n="U" oldref="146">
<item type="input">=MAXA(A1:B100)</item> returns the largest value from the list.</paragraph>
</section>
<section id="median">
<bookmark xml-lang="en-US" branch="index" id="bm_id3153820"><bookmark_value>MEDIAN function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_MEDIAN" id="bm_id3153069" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3153820" role="heading" level="2" l10n="U"
oldref="11">MEDIAN</paragraph>
<paragraph xml-lang="en-US" id="par_id3151241" role="paragraph" l10n="U" oldref="12"><ahelp hid="HID_FUNC_MEDIAN">Returns the median of a set of numbers. In a set containing an uneven number of values, the median will be the number in the middle of the set and in a set containing an even number of values, it will be the mean of the two values in the middle of the set.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3148871" role="heading" level="3" l10n="U"
oldref="13">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3155264" role="code" l10n="U" oldref="14">MEDIAN(Number1; Number2; ...Number30)</paragraph>
<paragraph xml-lang="en-US" id="par_id3150109" role="paragraph" l10n="CHG" oldref="15"><emph>Number1; Number2;...Number30</emph> are values or ranges, which represent a sample. Each number can also be replaced by a reference.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3144506" role="heading" level="3" l10n="U"
oldref="16">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3145078" role="paragraph" l10n="U" oldref="17">for an odd number: <item type="input">=MEDIAN(1;5;9;20;21)</item> returns 9 as the median value.</paragraph>
<paragraph xml-lang="en-US" id="par_id3149126" role="paragraph" l10n="U" oldref="165">for an even number: <item type="input">=MEDIAN(1;5;9;20)</item> returns the average of the two middle values 5 and 9, thus 7.</paragraph>
</section>
<section id="min">
<bookmark xml-lang="en-US" branch="index" id="bm_id3154541"><bookmark_value>MIN function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_MIN" id="bm_id3159226" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3154541" role="heading" level="2" l10n="U"
oldref="19">MIN</paragraph>
<paragraph xml-lang="en-US" id="par_id3143222" role="paragraph" l10n="U" oldref="20"><ahelp hid="HID_FUNC_MIN">Returns the minimum value in a list of arguments.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="par_id2301400" role="paragraph" l10n="NEW">Returns 0 if no numeric value and no error was encountered in the cell range(s) passed as cell reference(s). Text cells are ignored by MIN() and MAX(). The functions MINA() and MAXA() return 0 if no value (numeric or text) and no error was encountered. Passing a literal string argument to MIN() or MAX(), e.g. MIN("string"), still results in an error.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3154651" role="heading" level="3" l10n="U"
oldref="21">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3146964" role="code" l10n="U" oldref="22">MIN(Number1; Number2; ...Number30)</paragraph>
<paragraph xml-lang="en-US" id="par_id3153486" role="paragraph" l10n="CHG" oldref="23"><emph>Number1; Number2;...Number30</emph> are numerical values or ranges.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3155523" role="heading" level="3" l10n="U"
oldref="24">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3154734" role="paragraph" l10n="U" oldref="25">
<item type="input">=MIN(A1:B100)</item> returns the smallest value in the list.</paragraph>
</section>
<section id="mina">
<bookmark xml-lang="en-US" branch="index" id="bm_id3147504"><bookmark_value>MINA function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_MINA" id="bm_id3155752" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3147504" role="heading" level="2" l10n="U"
oldref="148">MINA</paragraph>
<paragraph xml-lang="en-US" id="par_id3147249" role="paragraph" l10n="U" oldref="149"><ahelp hid="HID_FUNC_MINA">Returns the minimum value in a list of arguments. Here you can also enter text. The value of the text is 0.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="par_id4294564" role="paragraph" l10n="NEW">The functions MINA() and MAXA() return 0 if no value (numeric or text) and no error was encountered.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3150435" role="heading" level="3" l10n="U"
oldref="150">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3153336" role="code" l10n="U" oldref="151">MINA(Value1; Value2; ... Value30)</paragraph>
<paragraph xml-lang="en-US" id="par_id3146098" role="paragraph" l10n="CHG" oldref="152"><emph>Value1; Value2;...Value30</emph> are values or ranges. Text has the value of 0.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3148743" role="heading" level="3" l10n="U"
oldref="153">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3147401" role="paragraph" l10n="CHG" oldref="154">
<item type="input">=MINA(1;"Text";20)</item> returns 0.</paragraph>
<paragraph xml-lang="en-US" id="par_id3147295" role="paragraph" l10n="U" oldref="155">
<item type="input">=MINA(A1:B100)</item> returns the smallest value in the list.</paragraph>
</section>
<section id="avedev">
<bookmark xml-lang="en-US" branch="index" id="bm_id3166465"><bookmark_value>AVEDEV function</bookmark_value>
<bookmark_value>averages;statistical functions</bookmark_value>
</bookmark><comment>mw added "averages;"</comment>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_MITTELABW" id="bm_id3156396" localize="false"/>
<paragraph role="heading" id="hd_id3166465" xml-lang="en-US" level="2" l10n="U" oldref="27">AVEDEV</paragraph>
<paragraph role="paragraph" id="par_id3150373" xml-lang="en-US" l10n="U" oldref="28"><ahelp hid="HID_FUNC_MITTELABW">Returns the average of the absolute deviations of data points from their mean.</ahelp> Displays the diffusion in a data set.</paragraph>
<paragraph role="heading" id="hd_id3150038" xml-lang="en-US" level="3" l10n="U" oldref="29">Syntax</paragraph>
<paragraph role="code" id="par_id3145636" xml-lang="en-US" l10n="U" oldref="30">AVEDEV(Number1; Number2; ...Number30)</paragraph>
<paragraph role="paragraph" id="par_id3157871" xml-lang="en-US" l10n="U" oldref="31"><emph>Number1, Number2,...Number30</emph> are values or ranges that represent a sample. Each number can also be replaced by a reference.</paragraph>
<paragraph role="heading" id="hd_id3149725" xml-lang="en-US" level="3" l10n="U" oldref="32">Example</paragraph>
<paragraph role="paragraph" id="par_id3153122" xml-lang="en-US" l10n="U" oldref="33">
            <item type="input">=AVEDEV(A1:A50)</item>
         </paragraph>
</section>
<section id="average">
<bookmark xml-lang="en-US" branch="index" id="bm_id3145824"><bookmark_value>AVERAGE function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_MITTELWERT" id="bm_id3146878" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3145824" role="heading" level="2" l10n="U"
oldref="35">AVERAGE</paragraph>
<paragraph xml-lang="en-US" id="par_id3150482" role="paragraph" l10n="U" oldref="36"><ahelp hid="HID_FUNC_MITTELWERT">Returns the average of the arguments.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3146943" role="heading" level="3" l10n="U"
oldref="37">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3154679" role="code" l10n="U" oldref="38">AVERAGE(Number1; Number2; ...Number30)</paragraph>
<paragraph xml-lang="en-US" id="par_id3150741" role="paragraph" l10n="CHG" oldref="39"><emph>Number1; Number2;...Number 0</emph> are numerical values or ranges.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3153039" role="heading" level="3" l10n="U"
oldref="40">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3151232" role="paragraph" l10n="U" oldref="41">
<item type="input">=AVERAGE(A1:A50)</item>
</paragraph>
</section>
<section id="averagea">
<bookmark xml-lang="en-US" branch="index" id="bm_id3148754"><bookmark_value>AVERAGEA function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_MITTELWERTA" id="bm_id3149690" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3148754" role="heading" level="2" l10n="U"
oldref="157">AVERAGEA</paragraph>
<paragraph xml-lang="en-US" id="par_id3145138" role="paragraph" l10n="U" oldref="158"><ahelp hid="HID_FUNC_MITTELWERTA">Returns the average of the arguments. The value of a text is 0.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3153326" role="heading" level="3" l10n="U"
oldref="159">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3149734" role="code" l10n="U" oldref="160">AVERAGEA(Value1; Value2; ... Value30)</paragraph>
<paragraph xml-lang="en-US" id="par_id3155260" role="paragraph" l10n="CHG" oldref="161"><emph>Value1; Value2;...Value30</emph> are values or ranges. Text has the value of 0.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3149504" role="heading" level="3" l10n="U"
oldref="162">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3150864" role="paragraph" l10n="U" oldref="163">
<item type="input">=AVERAGEA(A1:A50)</item>
</paragraph>
</section>
<section id="averageif">
<bookmark xml-lang="en-US" branch="index" id="bm_id3148754K1"><bookmark_value>AVERAGEIF function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_MITTELWERTB" id="bm_id3149690K1" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3148754K1" role="heading" level="2" l10n="U"
	oldref="157">AVERAGEIF</paragraph><comment>kschenk added this entry </comment>
<paragraph xml-lang="en-US" id="par_id3145138K1" role="paragraph" l10n="U"><ahelp hid="HID_FUNC_MITTELWERTB">Average the values of cells in a range that meet a criteria.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3153326K1" role="heading" level="3" l10n="U"
oldref="159">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3149734K1" role="code" l10n="U" >AVERAGEIF( Reference R ; Criterion C [ ; Reference A ] )</paragraph>
<paragraph xml-lang="en-US" id="par_id3155260K1" role="paragraph" l10n="CHG" > If reference A is omitted, averages the values of cells in the reference range R that meet the Criterion C. If reference A is given, averages the values of cells of a range that is constructed using the top left cell of reference A and applying the dimensions, shape and size, of reference R.  Does not accept constant values as reference parameters.</paragraph>
<paragraph xml-lang="en-US" id="par_id3145139K1" role="paragraph" l10n="U" >If no cell in range R matches the Criterion C, an Error is returned. If no Numbers are in the range to be averaged, an Error is returned.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3149504K1" role="heading" level="3" l10n="U"
oldref="162">Examples</paragraph>
<paragraph xml-lang="en-US" id="par_id3150864K1" role="paragraph" l10n="U">
<item type="input">=AVERAGEIF(A1:A50;"&gt;"0)</item>
will return the average of A1:A50 of all positive values in the range.
</paragraph>
</section>
<section id="averageifs">
<bookmark xml-lang="en-US" branch="index" id="bm_id3148754K2"><bookmark_value>AVERAGEIFS function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_MITTELWERTC" id="bm_id3149690K2" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3148754K2" role="heading" level="2" l10n="U"
	oldref="157">AVERAGEIFS</paragraph><comment>kschenk added this entry </comment>
<paragraph xml-lang="en-US" id="par_id3145138K2" role="paragraph" l10n="U"><ahelp hid="HID_FUNC_MITTELWERTC">Average the values of cells that meet multiple criteria in multiple ranges.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3153326K2" role="heading" level="3" l10n="U"
oldref="159">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3149734K2" role="code" l10n="U" >AVERAGEIFS( Reference A ; Reference R1 ; Criterion C1 [ ; Reference R2 ; Criterion C2 ]... )</paragraph>
<paragraph xml-lang="en-US" id="par_id3155260K2" role="paragraph" l10n="CHG" >Averages the values of cells in the reference range A that meet the Criterion C1 in the reference range R1 and the Criterion C2 in the reference range R2, and so on.</paragraph>
<paragraph xml-lang="en-US" id="par_id3145139K2" role="paragraph" l10n="U" >All reference ranges shall have the same dimension and size, else an Error is returned. A logical AND is applied between each array result of each selection; a cell of reference range A is evaluated only if the same position in each array is the result of a Criterion match. If no numbers are in the result set to be averaged, an Error is returned.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3149504K2" role="heading" level="3" l10n="U"
oldref="162">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3150864K2" role="paragraph" l10n="U">
<item type="input">=AVERAGEIFS(A1:A50;B1:B25;"&gt;"0)</item>+will return the average of A1:A50 if all cells in the range B1 to B25 are greater than 0.
</paragraph>
</section>
<section id="mode">
<bookmark xml-lang="en-US" branch="index" id="bm_id3153933"><bookmark_value>MODE function</bookmark_value>
<bookmark_value>most common value</bookmark_value>
</bookmark><comment>mw added one entry</comment>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_MODALWERT" id="bm_id3149253" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3153933" role="heading" level="2" l10n="U"
oldref="43">MODE</paragraph>
<paragraph xml-lang="en-US" id="par_id3153085" role="paragraph" l10n="U" oldref="44"><ahelp hid="HID_FUNC_MODALWERT">Returns the most common value in a data set.</ahelp> If there are several values with the same frequency, it returns the smallest value. An error occurs when a value doesn't appear twice.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3153003" role="heading" level="3" l10n="U"
oldref="45">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3155950" role="code" l10n="U" oldref="46">MODE(Number1; Number2; ...Number30)</paragraph>
<paragraph xml-lang="en-US" id="par_id3150337" role="paragraph" l10n="CHG" oldref="47"><emph>Number1; Number2;...Number30</emph> are numerical values or ranges.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3153571" role="heading" level="3" l10n="U"
oldref="48">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3153733" role="paragraph" l10n="U" oldref="49">
<item type="input">=MODE(A1:A50)</item>
</paragraph>
</section>
<section id="negbinomdist">
<bookmark xml-lang="en-US" branch="index" id="bm_id3149879"><bookmark_value>NEGBINOMDIST function</bookmark_value>
<bookmark_value>negative binomial distribution</bookmark_value>
</bookmark><comment>mw added one entry</comment>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_NEGBINOMVERT" id="bm_id3159135" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3149879" role="heading" level="2" l10n="U"
oldref="51">NEGBINOMDIST</paragraph>
<paragraph xml-lang="en-US" id="par_id3155437" role="paragraph" l10n="U" oldref="52"><ahelp hid="HID_FUNC_NEGBINOMVERT">Returns the negative binomial distribution.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3145351" role="heading" level="3" l10n="U"
oldref="53">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3150935" role="code" l10n="U" oldref="54">NEGBINOMDIST(X; R; SP)</paragraph>
<paragraph xml-lang="en-US" id="par_id3153044" role="paragraph" l10n="U" oldref="55"><emph>X</emph> represents the value returned for unsuccessful tests.</paragraph>
<paragraph xml-lang="en-US" id="par_id3151018" role="paragraph" l10n="U" oldref="56"><emph>R</emph> represents the value returned for successful tests.</paragraph>
<paragraph xml-lang="en-US" id="par_id3148878" role="paragraph" l10n="U" oldref="57"><emph>SP</emph> is the probability of the success of an attempt.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3149539" role="heading" level="3" l10n="U"
oldref="58">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3148770" role="paragraph" l10n="U" oldref="59">
<item type="input">=NEGBINOMDIST(1;1;0.5)</item> returns 0.25.</paragraph>
</section>
<section id="norminv">
<bookmark xml-lang="en-US" branch="index" id="bm_id3155516"><bookmark_value>NORMINV function</bookmark_value>
<bookmark_value>normal distribution;inverse of</bookmark_value>
</bookmark><comment>mw added one entry</comment>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_NORMINV" id="bm_id3149396" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3155516" role="heading" level="2" l10n="U"
oldref="61">NORMINV</paragraph>
<paragraph xml-lang="en-US" id="par_id3154634" role="paragraph" l10n="U" oldref="62"><ahelp hid="HID_FUNC_NORMINV">Returns the inverse of the normal cumulative distribution.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3153227" role="heading" level="3" l10n="U"
oldref="63">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3147534" role="code" l10n="U" oldref="64">NORMINV(Number; Mean; StDev)</paragraph>
<paragraph xml-lang="en-US" id="par_id3154950" role="paragraph" l10n="U" oldref="65"><emph>Number</emph> represents the probability value used to determine the inverse normal distribution.</paragraph>
<paragraph xml-lang="en-US" id="par_id3150690" role="paragraph" l10n="U" oldref="66"><emph>Mean</emph> represents the mean value in the normal distribution.</paragraph>
<paragraph xml-lang="en-US" id="par_id3148594" role="paragraph" l10n="U" oldref="67"><emph>StDev</emph> represents the standard deviation of the normal distribution.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3155822" role="heading" level="3" l10n="U"
oldref="68">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3153921" role="paragraph" l10n="CHG" oldref="69">
<item type="input">=NORMINV(0.9;63;5)</item> returns 69.41. If the average egg weighs 63 grams with a standard deviation of 5, then there will be 90% probability that the egg will not be heavier than 69.41g grams.</paragraph>
</section>
<section id="normdist">
<bookmark xml-lang="en-US" branch="index" id="bm_id3153722"><bookmark_value>NORMDIST function</bookmark_value>
<bookmark_value>density function</bookmark_value>
</bookmark><comment>mw added one entry</comment>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_NORMVERT" id="bm_id3147484" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3153722" role="heading" level="2" l10n="U"
oldref="71">NORMDIST</paragraph>
<paragraph xml-lang="en-US" id="par_id3150386" role="paragraph" l10n="CHG" oldref="72"><ahelp hid="HID_FUNC_NORMVERT">Returns the density function or the normal cumulative distribution.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3083282" role="heading" level="3" l10n="U"
oldref="73">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3150613" role="code" l10n="U" oldref="74">NORMDIST(Number; Mean; StDev; C)</paragraph>
<paragraph xml-lang="en-US" id="par_id3149820" role="paragraph" l10n="U" oldref="75"><emph>Number</emph> is the value of the distribution based on which the normal distribution is to be calculated.</paragraph>
<paragraph xml-lang="en-US" id="par_id3146063" role="paragraph" l10n="U" oldref="76"><emph>Mean</emph> is the mean value of the distribution.</paragraph>
<paragraph xml-lang="en-US" id="par_id3156295" role="paragraph" l10n="U" oldref="77"><emph>StDev</emph> is the standard deviation of the distribution.</paragraph>
<paragraph xml-lang="en-US" id="par_id3145080" role="paragraph" l10n="U" oldref="78"><emph>C</emph> is optional. <emph>C</emph> = 0 calculates the density function, <emph>C</emph> = 1 calculates the distribution.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3152972" role="heading" level="3" l10n="U"
oldref="79">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3149283" role="paragraph" l10n="CHG" oldref="80">
<item type="input">=NORMDIST(70;63;5;0)</item> returns 0.03.</paragraph>
<paragraph xml-lang="en-US" id="par_id3149448" role="paragraph" l10n="CHG" oldref="81">
<item type="input">=NORMDIST(70;63;5;1)</item> returns 0.92.</paragraph>
</section>
<section id="pearson">
<bookmark xml-lang="en-US" branch="index" id="bm_id3152934"><bookmark_value>PEARSON function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_PEARSON" id="bm_id3156103" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3152934" role="heading" level="2" l10n="U"
oldref="83">PEARSON</paragraph>
<paragraph xml-lang="en-US" id="par_id3153216" role="paragraph" l10n="U" oldref="84"><ahelp hid="HID_FUNC_PEARSON">Returns the Pearson product moment correlation coefficient r.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3147081" role="heading" level="3" l10n="U"
oldref="85">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3156133" role="code" l10n="U" oldref="86">PEARSON(Data1; Data2)</paragraph>
<paragraph xml-lang="en-US" id="par_id3151272" role="paragraph" l10n="U" oldref="87"><emph>Data1</emph> represents the array of the first data set.</paragraph>
<paragraph xml-lang="en-US" id="par_id3153279" role="paragraph" l10n="U" oldref="88"><emph>Data2</emph> represents the array of the second data set.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3147567" role="heading" level="3" l10n="U"
oldref="89">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3151187" role="paragraph" l10n="U" oldref="90">
<item type="input">=PEARSON(A1:A30;B1:B30)</item> returns the Pearson correlation coefficient of both data sets.</paragraph>
</section>
<section id="phi">
<bookmark xml-lang="en-US" branch="index" id="bm_id3152806"><bookmark_value>PHI function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_PHI" id="bm_id3153757" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3152806" role="heading" level="2" l10n="U"
oldref="92">PHI</paragraph>
<paragraph xml-lang="en-US" id="par_id3150254" role="paragraph" l10n="U" oldref="93"><ahelp hid="HID_FUNC_PHI">Returns the values of the distribution function for a standard normal distribution.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3154748" role="heading" level="3" l10n="U"
oldref="94">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3149976" role="code" l10n="U" oldref="95">PHI(Number)</paragraph>
<paragraph xml-lang="en-US" id="par_id3156108" role="paragraph" l10n="U" oldref="96"><emph>Number</emph> represents the value based on which the standard normal distribution is calculated.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3153621" role="heading" level="3" l10n="U"
oldref="97">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3155849" role="paragraph" l10n="CHG" oldref="98">
<item type="input">=PHI(2.25) </item>= 0.03</paragraph>
<paragraph xml-lang="en-US" id="par_id3143236" role="paragraph" l10n="CHG" oldref="99">
<item type="input">=PHI(-2.25)</item> = 0.03</paragraph>
<paragraph xml-lang="en-US" id="par_id3149286" role="paragraph" l10n="CHG" oldref="100">
<item type="input">=PHI(0)</item> = 0.4</paragraph>
</section>
<section id="poisson">
<bookmark xml-lang="en-US" branch="index" id="bm_id3153985"><bookmark_value>POISSON function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_POISSON" id="bm_id3156011" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3153985" role="heading" level="2" oldref="102">POISSON</paragraph>
<paragraph xml-lang="en-US" id="par_id3154298" role="paragraph" l10n="U" oldref="103"><ahelp hid="HID_FUNC_POISSON">Returns the Poisson distribution.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3159183" role="heading" level="3" l10n="U"
oldref="104">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3146093" role="code" l10n="U" oldref="105">POISSON(Number; Mean; C)</paragraph>
<paragraph xml-lang="en-US" id="par_id3147253" role="paragraph" l10n="U" oldref="106"><emph>Number</emph> represents the value based on which the Poisson distribution is calculated.</paragraph>
<paragraph xml-lang="en-US" id="par_id3151177" role="paragraph" l10n="U" oldref="107"><emph>Mean</emph> represents the middle value of the Poisson distribution.</paragraph>
<paragraph xml-lang="en-US" id="par_id3149200" role="paragraph" l10n="CHG" oldref="108"><emph>C</emph> (optional) = 0 or False calculates the density function; <emph>C</emph> = 1 or True calculates the distribution. When omitted, the default value True is inserted when you save the document, for best compatibility with other programs and older versions of %PRODUCTNAME.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3159347" role="heading" level="3" l10n="U"
oldref="109">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3150113" role="paragraph" l10n="U" oldref="110">
<item type="input">=POISSON(60;50;1)</item> returns 0.93.</paragraph>
</section>
<section id="percentile">
<bookmark xml-lang="en-US" branch="index" id="bm_id3153100"><bookmark_value>PERCENTILE function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_QUANTIL" id="bm_id3155394" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3153100" role="heading" level="2" l10n="U"
oldref="112">PERCENTILE</paragraph>
<paragraph xml-lang="en-US" id="par_id3154940" role="paragraph" l10n="U" oldref="113"><ahelp hid="HID_FUNC_QUANTIL">Returns the alpha-percentile of data values in an array.</ahelp> A percentile returns the scale value for a data series which goes from the smallest (Alpha=0) to the largest value (alpha=1) of a data series. For <item type="literal">Alpha</item> = 25%, the percentile means the first quartile; <item type="literal">Alpha</item> = 50% is the MEDIAN.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3150531" role="heading" level="3" l10n="U"
oldref="114">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3148813" role="code" l10n="U" oldref="115">PERCENTILE(Data; Alpha)</paragraph>
<paragraph xml-lang="en-US" id="par_id3153054" role="paragraph" l10n="U" oldref="116"><emph>Data</emph> represents the array of data.</paragraph>
<paragraph xml-lang="en-US" id="par_id3154212" role="paragraph" l10n="U" oldref="117"><emph>Alpha</emph> represents the percentage of the scale between 0 and 1.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3154290" role="heading" level="3" l10n="U"
oldref="118">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3159147" role="paragraph" l10n="CHG" oldref="119">
<item type="input">=PERCENTILE(A1:A50;0.1)</item> represents the value in the data set, which equals 10% of the total data scale in A1:A50.</paragraph>
</section>
<section id="percentrank">
<bookmark xml-lang="en-US" branch="index" id="bm_id3148807"><bookmark_value>PERCENTRANK function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_QUANTILSRANG" id="bm_id3154902" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3148807" role="heading" level="2" l10n="U"
oldref="121">PERCENTRANK</paragraph>
<paragraph xml-lang="en-US" id="par_id3153573" role="paragraph" l10n="U" oldref="122"><ahelp hid="HID_FUNC_QUANTILSRANG">Returns the percentage rank of a value in a sample.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3147512" role="heading" level="3" l10n="U"
oldref="123">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3147238" role="code" l10n="U" oldref="124">PERCENTRANK(Data; Value)</paragraph>
<paragraph xml-lang="en-US" id="par_id3154266" role="paragraph" l10n="U" oldref="125"><emph>Data</emph> represents the array of data in the sample.</paragraph>
<paragraph xml-lang="en-US" id="par_id3148475" role="paragraph" l10n="U" oldref="126"><emph>Value</emph> represents the value whose percentile rank must be determined.</paragraph>
<paragraph xml-lang="en-US" id="hd_id3155364" role="heading" level="3" l10n="U"
oldref="127">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3149163" role="paragraph" l10n="U" oldref="128">
<item type="input">=PERCENTRANK(A1:A50;50)</item> returns the percentage rank of the value 50 from the total range of all values found in A1:A50. If 50 falls outside the total range, an error message will appear.</paragraph>
</section>
<section id="quartile">
<bookmark xml-lang="en-US" branch="index" id="bm_id3166442"><bookmark_value>QUARTILE function</bookmark_value>
</bookmark>
<bookmark xml-lang="en-US" branch="hid/SC_HID_FUNC_QUARTILE" id="bm_id3150709" localize="false"/>
<paragraph xml-lang="en-US" id="hd_id3166442" role="heading" level="2" l10n="U"
oldref="130">QUARTILE</paragraph>
<paragraph xml-lang="en-US" id="par_id3146958" role="paragraph" l10n="U" oldref="131"><ahelp hid="HID_FUNC_QUARTILE">Returns the quartile of a data set.</ahelp></paragraph>
<paragraph xml-lang="en-US" id="hd_id3152942" role="heading" level="3" l10n="U"
oldref="132">Syntax</paragraph>
<paragraph xml-lang="en-US" id="par_id3153684" role="code" l10n="U" oldref="133">QUARTILE(Data; Type)</paragraph>
<paragraph xml-lang="en-US" id="par_id3153387" role="paragraph" l10n="U" oldref="134"><emph>Data</emph> represents the array of data in the sample.</paragraph>
<paragraph xml-lang="en-US" id="par_id3155589" role="paragraph" l10n="U" oldref="135"><emph>Type</emph> represents the type of quartile. (0 = MIN, 1 = 25%, 2 = 50% (MEDIAN), 3 = 75% and 4 = MAX.)</paragraph>
<paragraph xml-lang="en-US" id="hd_id3149103" role="heading" level="3" l10n="U"
oldref="136">Example</paragraph>
<paragraph xml-lang="en-US" id="par_id3159276" role="paragraph" l10n="CHG" oldref="137">
<item type="input">=QUARTILE(A1:A50;2)</item> returns the value of which 50% of the scale corresponds to the lowest to highest values in the range A1:A50.</paragraph>
</section>
</sort>
<section id="relatedtopics">
<embed href="text/scalc/01/04060100.xhp#drking"/>
</section>
</body>
</helpdocument>