lucene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ctarg...@apache.org
Subject [1/3] lucene-solr:jira/solr-11144: Completed round of copy edits
Date Wed, 18 Oct 2017 16:38:07 GMT
Repository: lucene-solr
Updated Branches:
  refs/heads/jira/solr-11144 [created] 3be44e535


Completed round of copy edits


Project: http://git-wip-us.apache.org/repos/asf/lucene-solr/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucene-solr/commit/3be44e53
Tree: http://git-wip-us.apache.org/repos/asf/lucene-solr/tree/3be44e53
Diff: http://git-wip-us.apache.org/repos/asf/lucene-solr/diff/3be44e53

Branch: refs/heads/jira/solr-11144
Commit: 3be44e535f95b3caed745851b0110d65f04e30ce
Parents: f7e3e4f
Author: Cassandra Targett <ctargett@apache.org>
Authored: Wed Oct 18 11:36:41 2017 -0500
Committer: Cassandra Targett <ctargett@apache.org>
Committed: Wed Oct 18 11:37:21 2017 -0500

----------------------------------------------------------------------
 .../src/analytics-expression-sources.adoc       |  68 ++-
 .../src/analytics-mapping-functions.adoc        | 417 +++++++++----------
 .../src/analytics-reduction-functions.adoc      |  65 ++-
 solr/solr-ref-guide/src/analytics.adoc          |  56 +--
 4 files changed, 283 insertions(+), 323 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/3be44e53/solr/solr-ref-guide/src/analytics-expression-sources.adoc
----------------------------------------------------------------------
diff --git a/solr/solr-ref-guide/src/analytics-expression-sources.adoc b/solr/solr-ref-guide/src/analytics-expression-sources.adoc
index 34f62fb..80038c1 100644
--- a/solr/solr-ref-guide/src/analytics-expression-sources.adoc
+++ b/solr/solr-ref-guide/src/analytics-expression-sources.adoc
@@ -2,7 +2,6 @@
 :page-shortname: analytics-expression-sources
 :page-permalink: analytics-expression-sources.html
 :page-tocclass: right
-:page-toclevels: 2
 // 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
@@ -22,74 +21,73 @@
 
 Expression sources are the source of the data being aggregated in <<analytics.adoc#expressions,analytics expressions>>.
 
-These sources can be either Solr Fields, indexed with docValues, or constants.
+These sources can be either Solr fields indexed with docValues, or constants.
 
-[[analytics-fields]]
-== Field Types
+== Supported Field Types
 
 The following <<field-types-included-with-solr.adoc#field-types-included-with-solr, Solr field types>> are supported.
-All field types are supported for both multi-valued and single-valued. +
-*All fields used in expressions must have <<docvalues.adoc#docvalues,docValues>> enabled*.
+Fields of these types can be either multi-valued and single-valued.
+
+All fields used in analytics expressions *must* have <<docvalues.adoc#docvalues,docValues>> enabled.
+
+
+// Since Trie* fields are deprecated as of 7.0, we should consider removing Trie* fields from this list...
 
 [horizontal]
 String::
-    * StrField
+    StrField
 Boolean::
-    * BoolField
+    BoolField
 Integer::
-    * TrieIntField
-    * IntPointField
+    TrieIntField +
+    IntPointField
 Long::
-    * TrieLongField
-    * LongPointField
+    TrieLongField +
+    LongPointField
 Float::
-    * TrieFloatField
-    * FloatPointField
+    TrieFloatField +
+    FloatPointField
 Double::
-    * TrieDoubleField
-    * DoublePointField
+    TrieDoubleField +
+    DoublePointField
 Date::
-    * TrieDateField
-    * DatePointField
+    TrieDateField +
+    DatePointField
 
-.Multi-valued Field Deduplication
+.Multi-valued Field De-duplication
 [WARNING]
 ====
-All multi-valued field types, except for *Point Fields*, are deduplicated. So duplicate values for the same field are removed during indexing.
-In order to save duplicates, you must use *Point Fields*.
+All multi-valued field types, except for PointFields, are de-duplicated, meaning duplicate values for the same field are removed during indexing.
+In order to save duplicates, you must use PointField types.
 ====
 
-[[analytics-constants]]
 == Constants
 
 Constants can be included in expressions to use along side fields and functions. The available constants are shown below.
 Constants do not need to be surrounded by any function to define them, they can be used exactly like fields in an expression.
 
-[[analytics-constant-string]]
 === Strings
 
 There are two possible ways of specifying constant strings, as shown below.
 
-* Surrounded by double quotes, inside the quotes both `"` and `\` must be escaped with a `\` character.
+. Surrounded by double quotes, inside the quotes both `"` and `\` must be escaped with a `\` character.
 +
-`"Inside of 'double' \\ \"quotes\""` *⟹* `Inside of 'double' \ "quotes"`
-* Surrounded by single quotes, inside the quotes both `'` and `\` must be escaped with a `\` character.
+`"Inside of 'double' \\ \"quotes\""` \=> `Inside of 'double' \ "quotes"`
+. Surrounded by single quotes, inside the quotes both `'` and `\` must be escaped with a `\` character.
 +
-`'Inside of "single" \\ \'quotes\''` *⟹* `Inside of "double" \ 'quotes'`
+`'Inside of "single" \\ \'quotes\''` \=> `Inside of "double" \ 'quotes'`
 
-[[analytics-constant-date]]
 === Dates
 
-Dates can be specified in the same way as they are in solr queries. Just use ISO-8601 format.
-For More information, refer to the <<working-with-dates.adoc#working-with-dates,Working with Dates>> section.
+Dates can be specified in the same way as they are in Solr queries. Just use ISO-8601 format.
+For more information, refer to the <<working-with-dates.adoc#working-with-dates,Working with Dates>> section.
 
 * `2017-07-17T19:35:08Z`
 
-[[analytics-constant-numeric]]
 === Numeric
 
-Any non-decimal number will be read as an *integer*, or a *long* if it is too large for an integer. All decimal numbers will be read as *doubles*.
+Any non-decimal number will be read as an integer, or as a long if it is too large for an integer. All decimal numbers will be read as doubles.
 
-* `-123421` - Integer
-* `800000000000` - Long
-* `230.34` - Double
+* `-123421`: Integer
+* `800000000000`: Long
+* `230.34`: Double

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/3be44e53/solr/solr-ref-guide/src/analytics-mapping-functions.adoc
----------------------------------------------------------------------
diff --git a/solr/solr-ref-guide/src/analytics-mapping-functions.adoc b/solr/solr-ref-guide/src/analytics-mapping-functions.adoc
index aecd12f..62ea2f9 100644
--- a/solr/solr-ref-guide/src/analytics-mapping-functions.adoc
+++ b/solr/solr-ref-guide/src/analytics-mapping-functions.adoc
@@ -2,7 +2,6 @@
 :page-shortname: analytics-mapping-functions
 :page-permalink: analytics-mapping-functions.html
 :page-tocclass: right
-:page-toclevels: 2
 // 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
@@ -25,365 +24,339 @@ Mapping functions map values for each Solr Document or Reduction.
 Below is a list of all mapping functions provided by the Analytics Component.
 These mappings can be chained together to implement more complex functionality.
 
-[[analytics-mapping-numeric]]
-== Numeric
-[[analytics-mapping-num-neg]]
+== Numeric Functions
+
 === Negation
 Negates the result of a numeric expression.
 
-`*neg*(< _Numeric_ *T* >) *⟹* < *T* >`::
-    * `neg(10.53) ⟹ -10.53`
-    * `neg([1, -4]) ⟹ [-1, 4]`
+`neg(<_Numeric_ T>)` \=> `<T>`::
+    * `neg(10.53)` \=> `-10.53`
+    * `neg([1, -4])` \=> `[-1, 4]`
 
-[[analytics-mapping-num-abs]]
 === Absolute Value
 Returns the absolute value of the numeric expression.
 
-`*abs*(< _Numeric_ *T* >) *⟹* < *T* >`::
-    * `abs(-10.53) ⟹ 10.53`
-    * `abs([1, -4]) ⟹ [1, 4]`
+`abs(< _Numeric_ T >)` \=> `< T >`::
+    * `abs(-10.53)` \=> `10.53`
+    * `abs([1, -4])` \=> `[1, 4]`
 
-[[analytics-mapping-num-round]]
+[[analytics-round]]
 === Round
 Rounds the numeric expression to the nearest `Integer` or `Long` value.
 
-`*round*(< _Float_ >) *⟹* < _Int_ >`::
-`*round*(< _Double_ >) *⟹* < _Long_ >`::
-    * `round(-1.5) ⟹ -1`
-    * `round([1.75, 100.34]) ⟹ [2, 100]`
+`round(< _Float_ >)` \=> `< _Int_ >`::
+`round(< _Double_ >)` \=> `< _Long_ >`::
+    * `round(-1.5)` \=> `-1`
+    * `round([1.75, 100.34])` \=> `[2, 100]`
 
-[[analytics-mapping-num-ceil]]
 === Ceiling
-Rounds the numeric expression to the nearest `Integer` or `Long` value that is *greater than or equal* to the original value.
+Rounds the numeric expression to the nearest `Integer` or `Long` value that is greater than or equal to the original value.
 
-`*ceil*(< _Float_ >) *⟹* < _Int_ >`::
-`*ceil*(< _Double_ >) *⟹* < _Long_ >`::
-    * `ceil(5.01) ⟹ 5`
-    * `ceil([-4.999, 6.99]) ⟹ [-4, 7]`
+`ceil(< _Float_ >)` \=> `< _Int_ >`::
+`ceil(< _Double_ >)` \=> `< _Long_ >`::
+    * `ceil(5.01)` \=> `5`
+    * `ceil([-4.999, 6.99])` \=> `[-4, 7]`
 
-[[analytics-mapping-num-floor]]
+[[analytics-floor]]
 === Floor
-Rounds the numeric expression to the nearest `Integer` or `Long` value that is *less than or equal* to the original value.
+Rounds the numeric expression to the nearest `Integer` or `Long` value that is less than or equal to the original value.
 
-`*floor*(< _Float_ >) *⟹* < _Int_ >`::
-`*floor*(< _Double_ >) *⟹* < _Long_ >`::
-    * `floor(5.75) ⟹ 5`
-    * `floor([-4.001, 6.01]) ⟹ [-5, 6]`
+`floor(< _Float_ >)` \=> `< _Int_ >`::
+`floor(< _Double_ >)` \=> `< _Long_ >`::
+    * `floor(5.75)` \=> `5`
+    * `floor([-4.001, 6.01])` \=> `[-5, 6]`
 
-[[analytics-mapping-num-add]]
 === Addition
 Adds the values of the numeric expressions.
 
-`*add*(< _Multi Double_ >) *⟹* < _Single Double_ >`::
-    * `add([1, -4]) ⟹ -3.0`
-`*add*(< _Single Double_ >, < _Multi Double_ >) *⟹* < _Multi Double_ >`::
-    * `add(3.5, [1, -4]) ⟹ [4.5, -0.5]`
-`*add*(< _Multi Double_ >, < _Single Double_ >) *⟹* < _Multi Double_ >`::
-    * `add([1, -4], 3.5) ⟹ [4.5, -0.5]`
-`*add*(< _Single Double_ >, ...) *⟹* < _Single Double_ >`::
-    * `add(3.5, 100, -27.6) ⟹ 75.9`
+`add(< _Multi Double_ >)` \=> `< _Single Double_ >`::
+    * `add([1, -4])` \=> `-3.0`
+`add(< _Single Double_ >, < _Multi Double_ >)` \=> `< _Multi Double_ >`::
+    * `add(3.5, [1, -4])` \=> `[4.5, -0.5]`
+`add(< _Multi Double_ >, < _Single Double_ >)` \=> `< _Multi Double_ >`::
+    * `add([1, -4], 3.5)` \=> `[4.5, -0.5]`
+`add(< _Single Double_ >, ...)` \=> `< _Single Double_ >`::
+    * `add(3.5, 100, -27.6)` \=> `75.9`
 
-[[analytics-mapping-num-sub]]
 === Subtraction
 Subtracts the values of the numeric expressions.
 
-`*sub*(< _Single Double_ >, < _Single Double_ >) *⟹* < _Single Double_ >`::
-    * `sub(3.5, 100) ⟹ -76.5`
-`*sub*(< _Single Double_ >, < _Multi Double_ >) *⟹* < _Multi Double_ >`::
-    * `sub(3.5, [1, -4]) ⟹ [2.5, 7.5]`
-`*sub*(< _Multi Double_ >, < _Single Double_ >) *⟹* < _Multi Double_ >`::
-    * `sub([1, -4], 3.5) ⟹ [-2.5, -7.5]`
+`sub(< _Single Double_ >, < _Single Double_ >)` \=> `< _Single Double_ >`::
+    * `sub(3.5, 100)` \=> `-76.5`
+`sub(< _Single Double_ >, < _Multi Double_ >)` \=> `< _Multi Double_ >`::
+    * `sub(3.5, [1, -4])` \=> `[2.5, 7.5]`
+`sub(< _Multi Double_ >, < _Single Double_ >)` \=> `< _Multi Double_ >`::
+    * `sub([1, -4], 3.5)` \=> `[-2.5, -7.5]`
 
-[[analytics-mapping-num-mult]]
 === Multiplication
 Multiplies the values of the numeric expressions.
 
-`*mult*(< _Multi Double_ >) *⟹* < _Single Double_ >`::
-    * `mult([1, -4]) ⟹ -4.0`
-`*mult*(< _Single Double_ >, < _Multi Double_ >) *⟹* < _Multi Double_ >`::
-    * `mult(3.5, [1, -4]) ⟹ [3.5, -16.0]`
-`*mult*(< _Multi Double_ >, < _Single Double_ >) *⟹* < _Multi Double_ >`::
-    * `mult([1, -4], 3.5) ⟹ [3.5, 16.0]`
-`*mult*(< _Single Double_ >, ...) *⟹* < _Single Double_ >`::
-    * `mult(3.5, 100, -27.6) ⟹ -9660`
+`mult(< _Multi Double_ >)` \=> `< _Single Double_ >`::
+    * `mult([1, -4])` \=> `-4.0`
+`mult(< _Single Double_ >, < _Multi Double_ >)` \=> `< _Multi Double_ >`::
+    * `mult(3.5, [1, -4])` \=> `[3.5, -16.0]`
+`mult(< _Multi Double_ >, < _Single Double_ >)` \=> `< _Multi Double_ >`::
+    * `mult([1, -4], 3.5)` \=> `[3.5, 16.0]`
+`mult(< _Single Double_ >, ...)` \=> `< _Single Double_ >`::
+    * `mult(3.5, 100, -27.6)` \=> `-9660`
 
-[[analytics-mapping-num-div]]
 === Division
 Divides the values of the numeric expressions.
 
-`*div*(< _Single Double_ >, < _Single Double_ >) *⟹* < _Single Double_ >`::
-    * `div(3.5, 100) ⟹ .035`
-`*div*(< _Single Double_ >, < _Multi Double_ >) *⟹* < _Multi Double_ >`::
-    * `div(3.5, [1, -4]) ⟹ [3.5, -0.875]`
-`*div*(< _Multi Double_ >, < _Single Double_ >) *⟹* < _Multi Double_ >`::
-    * `div([1, -4], 25) ⟹ [0.04, -0.16]`
+`div(< _Single Double_ >, < _Single Double_ >)` \=> `< _Single Double_ >`::
+    * `div(3.5, 100)` \=> `.035`
+`div(< _Single Double_ >, < _Multi Double_ >)` \=> `< _Multi Double_ >`::
+    * `div(3.5, [1, -4])` \=> `[3.5, -0.875]`
+`div(< _Multi Double_ >, < _Single Double_ >)` \=> `< _Multi Double_ >`::
+    * `div([1, -4], 25)` \=> `[0.04, -0.16]`
 
-[[analytics-mapping-num-pow]]
 === Power
-Takes one numeric expression to the power of another. 
+Takes one numeric expression to the power of another.
 
-*NOTE:* The square root function `*sqrt*(< _Double_ >)` can be used as shorthand for  `*pow*(< _Double_ >, .5)`
+*NOTE:* The square root function `sqrt(< _Double_ >)` can be used as shorthand for  `pow(< _Double_ >, .5)`
 
-`*pow*(< _Single Double_ >, < _Single Double_ >) *⟹* < _Single Double_ >`::
-    * `pow(2, 4) ⟹ 16.0`
-`*pow*(< _Single Double_ >, < _Multi Double_ >) *⟹* < _Multi Double_ >`::
-    * `pow(16, [-1, 0]) ⟹ [0.0625, 1]`
-`*pow*(< _Multi Double_ >, < _Single Double_ >) *⟹* < _Multi Double_ >`::
-    * `pow([1, 16], .25) ⟹ [1.0, 2.0]`
+`pow(< _Single Double_ >, < _Single Double_ >)` \=> `< _Single Double_ >`::
+    * `pow(2, 4)` \=> `16.0`
+`pow(< _Single Double_ >, < _Multi Double_ >)` \=> `< _Multi Double_ >`::
+    * `pow(16, [-1, 0])` \=> `[0.0625, 1]`
+`pow(< _Multi Double_ >, < _Single Double_ >)` \=> `< _Multi Double_ >`::
+    * `pow([1, 16], .25)` \=> `[1.0, 2.0]`
 
-[[analytics-mapping-num-log]]
 === Logarithm
 Takes one logarithm of numeric expressions, with an optional second numeric expression as the base.
 If only one expression is given, the natural log is used.
 
-`*log*(< _Double_ >) *⟹* < _Double_ >`::
-    * `log(5) *⟹* 1.6094...`
-    * `log([1.0, 100.34]) ⟹ [0.0, 4.6085...]`
-`*log*(< _Single Double_ >, < _Single Double_ >) *⟹* < _Single Double_ >`::
-    * `log(2, 4) ⟹ 0.5`
-`*log*(< _Single Double_ >, < _Multi Double_ >) *⟹* < _Multi Double_ >`::
-    * `log(16, [2, 4]) ⟹ [4, 2]`
-`*log*(< _Multi Double_ >, < _Single Double_ >) *⟹* < _Multi Double_ >`::
-    * `log([81, 3], 9) ⟹ [2.0, 0.5]`
-
-[[analytics-mapping-logic]]
+`log(< _Double_ >)` \=> `< _Double_ >`::
+    * `log(5)` \=> `1.6094...`
+    * `log([1.0, 100.34])` \=> `[0.0, 4.6085...]`
+`log(< _Single Double_ >, < _Single Double_ >)` \=> `< _Single Double_ >`::
+    * `log(2, 4)` \=> `0.5`
+`log(< _Single Double_ >, < _Multi Double_ >)` \=> `< _Multi Double_ >`::
+    * `log(16, [2, 4])` \=> `[4, 2]`
+`log(< _Multi Double_ >, < _Single Double_ >)` \=> `< _Multi Double_ >`::
+    * `log([81, 3], 9)` \=> `[2.0, 0.5]`
+
 == Logic
 
-[[analytics-mapping-logic-neg]]
+[[analytics-logic-neg]]
 === Negation
 Negates the result of a boolean expression.
 
-`*neg*(< _Bool_ >) *⟹* < _Bool_>`::
-    *  `neg(F) ⟹ T`
-    * `neg([F, T]) ⟹ [T, F]`
+`neg(< _Bool_ >)` \=> `< _Bool_>`::
+    *  `neg(F)` \=> `T`
+    * `neg([F, T])` \=> `[T, F]`
 
-[[analytics-mapping-logic-and]]
+[[analytics-and]]
 === And
 ANDs the values of the boolean expressions.
 
-`*and*(< _Multi Bool_ >) *⟹* < _Single Bool_ >`::
-    * `and([T, F, T]) ⟹ F`
-`*and*(< _Single Bool_ >, < _Multi Bool_ >) *⟹* < _Multi Bool_ >`::
-    * `and(F, [T, T]) ⟹ [F, F]`
-`*and*(< _Multi Bool_ >, < _Single Bool_ >) *⟹* < _Multi Bool_ >`::
-    * `and([F, T], T) ⟹ [F, T]`
-`*and*(< _Single Bool_ >, ...) *⟹* < _Single Bool_ >`::
-    * `and(T, T, T) ⟹ T`
+`and(< _Multi Bool_ >)` \=> `< _Single Bool_ >`::
+    * `and([T, F, T])` \=> `F`
+`and(< _Single Bool_ >, < _Multi Bool_ >)` \=> `< _Multi Bool_ >`::
+    * `and(F, [T, T])` \=> `[F, F]`
+`and(< _Multi Bool_ >, < _Single Bool_ >)` \=> `< _Multi Bool_ >`::
+    * `and([F, T], T)` \=> `[F, T]`
+`and(< _Single Bool_ >, ...)` \=> `< _Single Bool_ >`::
+    * `and(T, T, T)` \=> `T`
 
-[[analytics-mapping-logic-or]]
+[[analytics-or]]
 === Or
 ORs the values of the boolean expressions.
 
-`*or*(< _Multi Bool_ >) *⟹* < _Single Bool_ >`::
-    * `or([T, F, T]) ⟹ T`
-`*or*(< _Single Bool_ >, < _Multi Bool_ >) *⟹* < _Multi Bool_ >`::
-    * `or(F, [F, T]) ⟹ [F, T]`
-`*or*(< _Multi Bool_ >, < _Single Bool_ >) *⟹* < _Multi Bool_ >`::
-    * `or([F, T], T) ⟹ [T, T]`
-`*or*(< _Single Bool_ >, ...) *⟹* < _Single Bool_ >`::
-    * `or(F, F, F) ⟹ F`
+`or(< _Multi Bool_ >)` \=> `< _Single Bool_ >`::
+    * `or([T, F, T])` \=> `T`
+`or(< _Single Bool_ >, < _Multi Bool_ >)` \=> `< _Multi Bool_ >`::
+    * `or(F, [F, T])` \=> `[F, T]`
+`or(< _Multi Bool_ >, < _Single Bool_ >)` \=> `< _Multi Bool_ >`::
+    * `or([F, T], T)` \=> `[T, T]`
+`or(< _Single Bool_ >, ...)` \=> `< _Single Bool_ >`::
+    * `or(F, F, F)` \=> `F`
 
-[[analytics-mapping-logic-exists]]
 ==== Exists
 Checks whether any value(s) exist for the expression.
 
-`*exists*( *T* ) *⟹* < _Single Bool_ >`::
-    * `exists([1, 2, 3]) ⟹ T`
-    * `exists([]) ⟹ F`
-    * `exists(_empty_) ⟹ F`
-    * `exists('abc') ⟹ T`
+`exists( T )` \=> `< _Single Bool_ >`::
+    * `exists([1, 2, 3])` \=> `T`
+    * `exists([])` \=> `F`
+    * `exists(_empty_)` \=> `F`
+    * `exists('abc')` \=> `T`
 
-[[analytics-mapping-comparison]]
 == Comparison
 
-[[analytics-mapping-comp-equal]]
 === Equality
 Checks whether two expressions' values are equal. The parameters must be the same type, after implicit casting.
 
-`*equal*(< _Single_ *T* >, < _Single_ *T* >) *⟹* < _Single Bool_ >`::
-    * `equal(F, F) ⟹ T`
-`*equal*(< _Single_ *T* >, < _Multi_ *T* >) *⟹* < _Multi Bool_ >`::
-    * `equal("a", ["a", "ab"]) ⟹ [T, F]`
-`*equal*(< _Multi_ *T* >, < _Single_ *T* >) *⟹* < _Multi Bool_ >`::
-    * `equal([1.5, -3.0], -3) ⟹ [F, T]`
+`equal(< _Single_ T >, < _Single_ T >)` \=> `< _Single Bool_ >`::
+    * `equal(F, F)` \=> `T`
+`equal(< _Single_ T >, < _Multi_ T >)` \=> `< _Multi Bool_ >`::
+    * `equal("a", ["a", "ab"])` \=> `[T, F]`
+`equal(< _Multi_ T >, < _Single_ T >)` \=> `< _Multi Bool_ >`::
+    * `equal([1.5, -3.0], -3)` \=> `[F, T]`
 
-[[analytics-mapping-comp-gt]]
 === Greater Than
 Checks whether a numeric or `Date` expression's values are greater than another expression's values.
 The parameters must be the same type, after implicit casting.
 
-`*gt*(< _Single Numeric/Date_ *T* >, < _Single_ *T* >) *⟹* < _Single Bool_ >`::
-    * `gt(1800-01-02, 1799-12-20) ⟹ F`
-`*gt*(< _Single Numeric/Date_ *T* >, < _Multi_ *T* >) *⟹* < _Multi Bool_ >`::
-    * `gt(30.756, [30, 100]) ⟹ [F, T]`
-`*gt*(< _Multi Numeric/Date_ *T* >, < _Single_ *T* >) *⟹* < _Multi Bool_ >`::
-    * `gt([30, 75.6], 30) ⟹ [F, T]`
+`gt(< _Single Numeric/Date_ T >, < _Single_ T >)` \=> `< _Single Bool_ >`::
+    * `gt(1800-01-02, 1799-12-20)` \=> `F`
+`gt(< _Single Numeric/Date_ T >, < _Multi_ T >)` \=> `< _Multi Bool_ >`::
+    * `gt(30.756, [30, 100])` \=> `[F, T]`
+`gt(< _Multi Numeric/Date_ T >, < _Single_ T >)` \=> `< _Multi Bool_ >`::
+    * `gt([30, 75.6], 30)` \=> `[F, T]`
 
-[[analytics-mapping-comp-gte]]
 === Greater Than or Equals
 Checks whether a numeric or `Date` expression's values are greater than or equal to another expression's values.
 The parameters must be the same type, after implicit casting.
 
-`*gte*(< _Single Numeric/Date_ *T* >, < _Single_ *T* >) *⟹* < _Single Bool_ >`::
-    * `gte(1800-01-02, 1799-12-20) ⟹ F`
-`*gte*(< _Single Numeric/Date_ *T* >, < _Multi_ *T* >) *⟹* < _Multi Bool_ >`::
-    * `gte(30.756, [30, 100]) ⟹ [F, T]`
-`*gte*(< _Multi Numeric/Date_ *T* >, < _Single_ *T* >) *⟹* < _Multi Bool_ >`::
-    * `gte([30, 75.6], 30) ⟹ [T, T]`
+`gte(< _Single Numeric/Date_ T >, < _Single_ T >)` \=> `< _Single Bool_ >`::
+    * `gte(1800-01-02, 1799-12-20)` \=> `F`
+`gte(< _Single Numeric/Date_ T >, < _Multi_ T >)` \=> `< _Multi Bool_ >`::
+    * `gte(30.756, [30, 100])` \=> `[F, T]`
+`gte(< _Multi Numeric/Date_ T >, < _Single_ T >)` \=> `< _Multi Bool_ >`::
+    * `gte([30, 75.6], 30)` \=> `[T, T]`
 
-[[analytics-mapping-comp-lt]]
 === Less Than
 Checks whether a numeric or `Date` expression's values are less than another expression's values.
 The parameters must be the same type, after implicit casting.
 
-`*lt*(< _Single Numeric/Date_ *T* >, < _Single_ *T* >) *⟹* < _Single Bool_ >`::
-    * `lt(1800-01-02, 1799-12-20) ⟹ T`
-`*lt*(< _Single Numeric/Date_ *T* >, < _Multi_ *T* >) *⟹* < _Multi Bool_ >`::
-    * `lt(30.756, [30, 100]) ⟹ [T, F]`
-`*lt*(< _Multi Numeric/Date_ *T* >, < _Single_ *T* >) *⟹* < _Multi Bool_ >`::
-    * `lt([30, 75.6], 30) ⟹ [F, F]`
+`lt(< _Single Numeric/Date_ T >, < _Single_ T >)` \=> `< _Single Bool_ >`::
+    * `lt(1800-01-02, 1799-12-20)` \=> `T`
+`lt(< _Single Numeric/Date_ T >, < _Multi_ T >)` \=> `< _Multi Bool_ >`::
+    * `lt(30.756, [30, 100])` \=> `[T, F]`
+`lt(< _Multi Numeric/Date_ T >, < _Single_ T >)` \=> `< _Multi Bool_ >`::
+    * `lt([30, 75.6], 30)` \=> `[F, F]`
 
-[[analytics-mapping-comp-lte]]
 === Less Than or Equals
 Checks whether a numeric or `Date` expression's values are less than or equal to another expression's values.
 The parameters must be the same type, after implicit casting.
 
-`*lte*(< _Single Numeric/Date_ *T* >, < _Single_ *T* >) *⟹* < _Single Bool_ >`::
-    * `lte(1800-01-02, 1799-12-20) ⟹ T`
-`*lte*(< _Single Numeric/Date_ *T* >, < _Multi_ *T* >) *⟹* < _Multi Bool_ >`::
-    * `lte(30.756, [30, 100]) ⟹ [T, F]`
-`*lte*(< _Multi Numeric/Date_ *T* >, < _Single_ *T* >) *⟹* < _Multi Bool_ >`::
-    * `lte([30, 75.6], 30) ⟹ [T, F]`
+`lte(< _Single Numeric/Date_ T >, < _Single_ T >)` \=> `< _Single Bool_ >`::
+    * `lte(1800-01-02, 1799-12-20)` \=> `T`
+`lte(< _Single Numeric/Date_ T >, < _Multi_ T >)` \=> `< _Multi Bool_ >`::
+    * `lte(30.756, [30, 100])` \=> `[T, F]`
+`lte(< _Multi Numeric/Date_ T >, < _Single_ T >)` \=> `< _Multi Bool_ >`::
+    * `lte([30, 75.6], 30)` \=> `[T, F]`
 
-[[analytics-mapping-comp-top]]
+[[analytics-top]]
 === Top
 Returns the maximum of the numeric, `Date` or `String` expression(s)' values.
 The parameters must be the same type, after implicit casting.
 (Currently the only type not compatible is `Boolean`, which will be converted to a `String` implicitly in order to compile the expression)
 
-`*top*(< _Multi_ *T* >) *⟹* < _Single_ *T* >`::
-    * `top([30, 400, -10, 0]) ⟹ 400`
-`*top*(< _Single_ *T* >, ...) *⟹* < _Single_ *T* >`::
-    * `top("a", 1, "d") ⟹ "d"`
+`top(< _Multi_ T >)` \=> `< _Single_ T >`::
+    * `top([30, 400, -10, 0])` \=> `400`
+`top(< _Single_ T >, ...)` \=> `< _Single_ T >`::
+    * `top("a", 1, "d")` \=> `"d"`
 
-[[analytics-mapping-comp-bottom]]
 === Bottom
 Returns the minimum of the numeric, `Date` or `String` expression(s)' values.
 The parameters must be the same type, after implicit casting.
 (Currently the only type not compatible is `Boolean`, which will be converted to a `String` implicitly in order to compile the expression)
 
-`*bottom*(< _Multi_ *T* >) *⟹* < _Single_ *T* >`::
-    * `bottom([30, 400, -10, 0]) ⟹ -10`
-`*bottom*(< _Single_ *T* >, ...) *⟹* < _Single_ *T* >`::
-    * `bottom("a", 1, "d") ⟹ "1"`
+`bottom(< _Multi_ T >)` \=> `< _Single_ T >`::
+    * `bottom([30, 400, -10, 0])` \=> `-10`
+`bottom(< _Single_ T >, ...)` \=> `< _Single_ T >`::
+    * `bottom("a", 1, "d")` \=> `"1"`
 
-[[analytics-mapping-conditional]]
 == Conditional
 
-[[analytics-mapping-cond-if]]
+[[analytics-if]]
 === If
 Returns the value(s) of the `THEN` or `ELSE` expressions depending on whether the boolean conditional expression's value is `true` or `false`.
 The `THEN` and `ELSE` expressions must be of the same type and cardinality after implicit casting is done.
 
-`*if*(< _Single Bool_>, < *T* >, < *T* >) *⟹* < *T* >`::
-    * `if(true, "abc", [1,2]) ⟹ ["abc"]`
-    * `if(false, "abc", 123) ⟹ "123"`
+`if(< _Single Bool_>, < T >, < T >)` \=> `< T >`::
+    * `if(true, "abc", [1,2])` \=> `["abc"]`
+    * `if(false, "abc", 123)` \=> `"123"`
 
-[[analytics-mapping-cond-replace]]
 === Replace
-Replace all values from the *1^st^* expression that are equal to the value of the *2^nd^* expression with the value of the *3^rd^* expression.
+Replace all values from the 1^st^ expression that are equal to the value of the 2^nd^ expression with the value of the 3^rd^ expression.
 All parameters must be the same type after implicit casting is done.
 
-`*replace*(< *T* >, < _Single_ *T* >, < _Single_ *T* >) *⟹* < *T* >`::
-    * `replace([1,3], 3, "4") ⟹ ["1", "4"]`
-    * `replace("abc", "abc", 18) ⟹ "18"`
-    * `replace("abc", 1, "def") ⟹ "abc"`
+`replace(< T >, < _Single_ T >, < _Single_ T >)` \=> `< T >`::
+    * `replace([1,3], 3, "4")` \=> `["1", "4"]`
+    * `replace("abc", "abc", 18)` \=> `"18"`
+    * `replace("abc", 1, "def")` \=> `"abc"`
 
-[[analytics-mapping-cond-fill_missing]]
 === Fill Missing
-If the *1^st^* expression does not have values, fill it with the values for the *2^nd^* expression.
+If the 1^st^ expression does not have values, fill it with the values for the 2^nd^ expression.
 Both expressions must be of the same type and cardinality after implicit casting is done
 
-`*fill_missing*(< *T* >, < *T* >) *⟹* < *T* >`::
-    * `fill_missing([], 3) ⟹ [3]`
-    * `fill_missing(_empty_, "abc") ⟹ "abc"`
-    * `fill_missing("abc", [1]) ⟹ ["abc"]`
+`fill_missing(< T >, < T >)` \=> `< T >`::
+    * `fill_missing([], 3)` \=> `[3]`
+    * `fill_missing(_empty_, "abc")` \=> `"abc"`
+    * `fill_missing("abc", [1])` \=> `["abc"]`
 
-[[analytics-mapping-cond-remove]]
 === Remove
-Remove all occurences of the *2^nd^* expression's value from the values of the *1^st^* expression.
+Remove all occurrences of the 2^nd^ expression's value from the values of the 1^st^ expression.
 Both expressions must be of the same type after implicit casting is done
 
-`*remove*(< *T* >, < _Single_ *T* >) *⟹* < *T* >`::
-    * `remove([1,2,3,2], 2) ⟹ [1, 3]`
-    * `remove("1", 1) ⟹ _empty_`
-    * `remove(1, "abc") ⟹ "1"`
+`remove(< T >, < _Single_ T >)` \=> `< T >`::
+    * `remove([1,2,3,2], 2)` \=> `[1, 3]`
+    * `remove("1", 1)` \=> `_empty_`
+    * `remove(1, "abc")` \=> `"1"`
 
-[[analytics-mapping-cond-filter]]
 === Filter
-Return the values of the *1^st^* expression if the value of the *2^nd^* expression is `true`, otherwise return no values.
+Return the values of the 1^st^ expression if the value of the 2^nd^ expression is `true`, otherwise return no values.
 
-`*filter*(< *T* >, < _Single Boolean_ >) *⟹* < *T* >`::
-    * `filter([1,2,3], true) ⟹ [1,2,3]`
-    * `filter([1,2,3], false) ⟹ []`
-    * `filter("abc", false) ⟹ _empty_`
-    * `filter("abc", true) ⟹ 1`
+`filter(< T >, < _Single Boolean_ >)` \=> `< T >`::
+    * `filter([1,2,3], true)` \=> `[1,2,3]`
+    * `filter([1,2,3], false)` \=> `[]`
+    * `filter("abc", false)` \=> `_empty_`
+    * `filter("abc", true)` \=> `1`
 
-[[analytics-mapping-date]]
 == Date
 
-[[analytics-mapping-date-parse]]
 === Date Parse
 Explicitly converts the values of a `String` or `Long` expression into `Dates`.
 
-`*date*(< _String_ >) *⟹* < _Date_ >`::
-    * `date('1800-01-02') ⟹ 1800-01-02T&#8203;00:00:00Z`
-    * `date(['1800-01-02', '2016-05-23']) ⟹ [1800-01-02T..., 2016-05-23T...]`
-`*date*(< _Long_ >) *⟹* < _Date_ >`::
-    * `date(1232343246648) ⟹ 2009-01-19T&#8203;05:34:06Z`
-    * `date([1232343246648, 223234324664]) ⟹ [2009-01-19T..., 1977-01-27T...]`
+`date(< _String_ >)` \=> `< _Date_ >`::
+    * `date('1800-01-02')` \=> `1800-01-02T&#8203;00:00:00Z`
+    * `date(['1800-01-02', '2016-05-23'])` \=> `[1800-01-02T..., 2016-05-23T...]`
+`date(< _Long_ >)` \=> `< _Date_ >`::
+    * `date(1232343246648)` \=> `2009-01-19T&#8203;05:34:06Z`
+    * `date([1232343246648, 223234324664])` \=> `[2009-01-19T..., 1977-01-27T...]`
 
-[[analytics-mapping-date-math]]
+[[analytics-date-math]]
 === Date Math
-Compute the given date math strings for the values of a `Date` expression. The date math strings *must* be <<analytics-expression-sources.adoc#analytics-constant-string, constant>>.
+Compute the given date math strings for the values of a `Date` expression. The date math strings *must* be <<analytics-expression-sources.adoc#strings, constant>>.
 
-`*date_math*(< _Date_ >, < _Constant String_ >...) *⟹* < _Date_ >`::
-    * `date_math(1800-04-15, '+1DAY', '-1MONTH') ⟹ 1800-03-16`
-    * `date_math([1800-04-15,2016-05-24], '+1DAY', '-1MONTH') ⟹ [1800-03-16, 2016-04-25]`
+`date_math(< _Date_ >, < _Constant String_ >...)` \=> `< _Date_ >`::
+    * `date_math(1800-04-15, '+1DAY', '-1MONTH')` \=> `1800-03-16`
+    * `date_math([1800-04-15,2016-05-24], '+1DAY', '-1MONTH')` \=> `[1800-03-16, 2016-04-25]`
 
-[[analytics-mapping-string]]
 == String
 
 === Explicit Casting
 Explicitly casts the expression to a `String` expression.
 
-`*string*(< _String_ >) *⟹* < _String_ >`::
-    * `string(1) ⟹ '1'`
-    * `string([1.5, -2.0]) ⟹ ['1.5', '-2.0']`
+`string(< _String_ >)` \=> `< _String_ >`::
+    * `string(1)` \=> `'1'`
+    * `string([1.5, -2.0])` \=> `['1.5', '-2.0']`
 
 === Concatenation
 Concatenations the values of the `String` expression(s) together.
 
-`*concat*(< _Multi String_ >) *⟹* < _Single String_ >`::
-    * `concat(['a','b','c']) ⟹ 'abc'`
-`*concat*(< _Single String_ >, < _Multi String_ >) *⟹* < _Multi String_ >`::
-    * `concat(1, ['a','b','c']) ⟹ ['1a','1b','1c']`
-`*concat*(< _Multi String_ >, < _Single String_ >) *⟹* < _Multi String_ >`::
-    * `concat(['a','b','c'], 1) ⟹ ['a1','b1','c1']`
-`*concat*(< _Single String_ >...) *⟹* < _Single String_ >`::
-    * `concat('a','b','c') ⟹ 'abc'`
-    * `concat('a',_empty_,'c') ⟹ 'ac'` +
+`concat(< _Multi String_ >)` \=> `< _Single String_ >`::
+    * `concat(['a','b','c'])` \=> `'abc'`
+`concat(< _Single String_ >, < _Multi String_ >)` \=> `< _Multi String_ >`::
+    * `concat(1, ['a','b','c'])` \=> `['1a','1b','1c']`
+`concat(< _Multi String_ >, < _Single String_ >)` \=> `< _Multi String_ >`::
+    * `concat(['a','b','c'], 1)` \=> `['a1','b1','c1']`
+`concat(< _Single String_ >...)` \=> `< _Single String_ >`::
+    * `concat('a','b','c')` \=> `'abc'`
+    * `concat('a',_empty_,'c')` \=> `'ac'` +
     _Empty values are ignored_
 
 === Separated Concatenation
-Concatenations the values of the `String` expression(s) together using the given <<analytics-expression-sources.adoc#analytics-constant-string, *constant String*>> value as a separator.
-
-`*concat_sep*(< _Constant String_ >, < _Multi String_ >) *⟹* < _Single String_ >`::
-    * `concat_sep('-', ['a','b']) ⟹ 'a-b'`
-`*concat_sep*(< _Constant String_ >, < _Single String_ >, < _Multi String_ >) *⟹* < _Multi String_ >`::
-    * `concat_sep(2,1,['a','b']) ⟹ ['12a','12b']`
-`*concat_sep*(< _Constant String_ >, < _Multi String_ >, < _Single String_ >) *⟹* < _Multi String_ >`::
-    * `concat_sep(2,['a','b'],1) ⟹ ['a21','b21']` 
-    * `concat_sep('-','a',2,3) ⟹ 'a-2-3'`
-    * `concat_sep(';','a',_empty_,'c') ⟹ 'a;c'` +
-_Empty values are ignored_
\ No newline at end of file
+Concatenations the values of the `String` expression(s) together using the given <<analytics-expression-sources.adoc#strings, constant string>> value as a separator.
+
+`concat_sep(< _Constant String_ >, < _Multi String_ >)` \=> `< _Single String_ >`::
+    * `concat_sep('-', ['a','b'])` \=> `'a-b'`
+`concat_sep(< _Constant String_ >, < _Single String_ >, < _Multi String_ >)` \=> `< _Multi String_ >`::
+    * `concat_sep(2,1,['a','b'])` \=> `['12a','12b']`
+`concat_sep(< _Constant String_ >, < _Multi String_ >, < _Single String_ >)` \=> `< _Multi String_ >`::
+    * `concat_sep(2,['a','b'],1)` \=> `['a21','b21']`
+    * `concat_sep('-','a',2,3)` \=> `'a-2-3'`
+    * `concat_sep(';','a',_empty_,'c')` \=> `'a;c'` +
+_Empty values are ignored_

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/3be44e53/solr/solr-ref-guide/src/analytics-reduction-functions.adoc
----------------------------------------------------------------------
diff --git a/solr/solr-ref-guide/src/analytics-reduction-functions.adoc b/solr/solr-ref-guide/src/analytics-reduction-functions.adoc
index bc1b661..4d97806 100644
--- a/solr/solr-ref-guide/src/analytics-reduction-functions.adoc
+++ b/solr/solr-ref-guide/src/analytics-reduction-functions.adoc
@@ -27,111 +27,96 @@ for every Solr Document to a single value.
 Below is a list of all reduction functions provided by the Analytics Component.
 These can be combined using mapping functions to implement more complex functionality.
 
-[[analytics-reduction-counting]]
 == Counting Reductions
 
-[[analytics-reduction-count]]
 === Count
-The number of existing values for an expression. For single-valued expressions, this is equivalent to `*docCount*`.
+The number of existing values for an expression. For single-valued expressions, this is equivalent to `docCount`.
 If no expression is given, the number of matching documents is returned.
 
-`*count*() *⟹* < _Single Long_ >`::
-`*count*(< *T* >) *⟹* < _Single Long_ >`::
+`count()` \=> `< _Single Long_ >`
+`count(< T >)` \=> `< _Single Long_ >`
 
-[[analytics-reduction-doc_count]]
 === Doc Count
-The number of documents for which an expression has existing values. For single-valued expressions, this is equivalent to `*count*`.
+The number of documents for which an expression has existing values. For single-valued expressions, this is equivalent to `count`.
 If no expression is given, the number of matching documents is returned.
 
-`*doc_count*() *⟹* < _Single Long_ >`::
-`*doc_count*(< *T* >) *⟹* < _Single Long_ >`::
+`doc_count()` \=> `< _Single Long_ >`
+
+`doc_count(< T >)` \=> `< _Single Long_ >`
 
-[[analytics-reduction-missing]]
 === Missing
 The number of documents for which an expression has no existing value.
 
-`*missing*(< *T* >) *⟹* < _Single Long_ >`::
+`missing(< T >)` \=> `< _Single Long_ >`
 
-[[analytics-reduction-unique]]
+[[analytics-unique]]
 === Unique
 The number of unique values for an expression. This function accepts `Numeric`, `Date` and `String` expressions.
 
-`*unique*(< *T* >) *⟹* < _Single Long_ >`::
+`unique(< T >)` \=> `< _Single Long_ >`
 
-[[analytics-reduction-math]]
 == Math Reductions
 
-[[analytics-reduction-sum]]
 === Sum
 Returns the sum of all values for the expression.
 
-`*sum*(< _Double_ >) *⟹* < _Single Double_ >`::
+`sum(< _Double_ >)` \=> `< _Single Double_ >`
 
-[[analytics-reduction-variance]]
 === Variance
 Returns the variance of all values for the expression.
 
-`*variance*(< _Double_ >) *⟹* < _Single Double_ >`::
+`variance(< _Double_ >)` \=> `< _Single Double_ >`
 
-[[analytics-reduction-stddev]]
 === Standard Deviation
 Returns the standard deviation of all values for the expression.
 
-`*stddev*(< _Double_ >) *⟹* < _Single Double_ >`::
+`stddev(< _Double_ >)` \=> `< _Single Double_ >`
 
-[[analytics-reduction-mean]]
 === Mean
 Returns the arithmetic mean of all values for the expression.
 
-`*mean*(< _Double_ >) *⟹* < _Single Double_ >`::
+`mean(< _Double_ >)` \=> `< _Single Double_ >`
 
-[[analytics-reduction-wmean]]
 === Weighted Mean
 Returns the arithmetic mean of all values for the second expression weighted by the values of the first expression.
 
-*NOTE*: The expressions must satisfy the rules for `mult` function parameters.
+`wmean(< _Double_ >, < _Double_ >)` \=> `< _Single Double_ >`
 
-`*wmean*(< _Double_ >, < _Double_ >) *⟹* < _Single Double_ >`::
+NOTE: The expressions must satisfy the rules for `mult` function parameters.
 
-[[analytics-reduction-ordering]]
 == Ordering Reductions
 
-[[analytics-reduction-min]]
 === Minimum
 Returns the minimum value for the expression. This function accepts `Numeric`, `Date` and `String` expressions.
 
-`*min*(< *T* >) *⟹* < _Single_ *T* >`::
+`min(< T >)` \=> `< _Single_ T >`
 
-[[analytics-reduction-max]]
 === Maximum
 Returns the maximum value for the expression. This function accepts `Numeric`, `Date` and `String` expressions.
 
-`*max*(< *T* >) *⟹* < _Single_ *T* >`::
+`max(< T >)` \=> `< _Single_ T >`
 
-[[analytics-reduction-median]]
 === Median
 Returns the median of all values for the expression. This function accepts `Numeric` and `Date` expressions.
 
-`*median*(< *T* >) *⟹* < _Single_ *T* >`::
+`median(< T >)` \=> `< _Single_ T >`
 
-[[analytics-reduction-percentile]]
 === Percentile
 Calculates the given percentile of all values for the expression.
 This function accepts `Numeric`, `Date` and `String` expressions for the 2^nd^ parameter.
 
-The percentile, given as the 1^st^ parameter, must be a <<analytics-expression-sources.adoc#analytics-constant-numeric,constant double>> between [0, 100).
+The percentile, given as the 1^st^ parameter, must be a <<analytics-expression-sources.adoc#numeric,constant double>> between [0, 100).
 
-`*percentile*(<Constant Double>, < *T* >) *⟹* < _Single_ *T* >`::
+`percentile(<Constant Double>, < T >)` \=> `< _Single_ T >`
 
-[[analytics-reduction-ordinal]]
 === Ordinal
 Calculates the given ordinal of all values for the expression.
 This function accepts `Numeric`, `Date` and `String` expressions for the 2^nd^ parameter.
-The ordinal, given as the 1^st^ parameter, must be a <<analytics-expression-sources.adoc#analytics-constant-numeric,constant integer>>. 
+The ordinal, given as the 1^st^ parameter, must be a <<analytics-expression-sources.adoc#numeric,constant integer>>.
 *0 is not accepted as an ordinal value.*
 
-If the ordinal is *positive*, the returned value will be the _n^th^_ *smallestvalue.
+If the ordinal is positive, the returned value will be the _n_^th^ smallest value.
 
-If the ordinal is *negative*, the returned value will be the _n^th^_ *largestvalue.
+If the ordinal is negative, the returned value will be the _n_^th^ largest value.
 
-`*ordinal*(<Constant Int>, < *T* >) *⟹* < _Single_ *T* >`::
\ No newline at end of file
+`ordinal(<Constant Int>, < T >)` \=> `< _Single_ T >`

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/3be44e53/solr/solr-ref-guide/src/analytics.adoc
----------------------------------------------------------------------
diff --git a/solr/solr-ref-guide/src/analytics.adoc b/solr/solr-ref-guide/src/analytics.adoc
index 5095476..d0a45e7 100644
--- a/solr/solr-ref-guide/src/analytics.adoc
+++ b/solr/solr-ref-guide/src/analytics.adoc
@@ -32,7 +32,7 @@ The Analytics component is in a contrib module, therefore it will need to be ena
 
 Since the Analytics framework is a _search component_, it must be declared as such and added to the search handler.
 
-For distributed analytics requests over cloud collections, the component uses the `AnalyticsHandler` *strictly for inter-shard communication*.
+For distributed analytics requests over cloud collections, the component uses the `AnalyticsHandler` strictly for inter-shard communication.
 The Analytics Handler should not be used by users to submit analytics requests.
 
 To configure Solr to use the Analytics Component, the first step is to add a `lib` directive so Solr loads the Analytic Component classes (for more about the `lib` directive, see <<lib-directives-in-solrconfig.adoc#lib-directives-in-solrconfig, Lib Directives in SolrConfig>>). In the section of `solrconfig.xml` where the default `lib` directive are, add a line:
@@ -161,10 +161,10 @@ An expression is built using fields, constants, mapping functions and reduction
 Sources::
     * Constants +
         Constants are values defined in the expression.
-        The supported constant types are described in the <<analytics-expression-sources.adoc#analytics-constants, Analytics Expression Source Reference>>
+        The supported constant types are described in the <<analytics-expression-sources.adoc#constants, Analytics Expression Source Reference>>
     * Fields +
         Solr fields that are read from the index.
-        The supported fields are listed in the <<analytics-expression-sources.adoc#analytics-fields, Analytics Expression Source Reference>>
+        The supported fields are listed in the <<analytics-expression-sources.adoc#supported-field-types, Analytics Expression Source Reference>>
 
 Mapping Functions::
 Functions that map values for each Solr Document or Reduction.
@@ -212,25 +212,25 @@ With the above definitions and ordering, an example expression can be broken up
 [source,bash]
 div(sum(a,fill_missing(b,0)),add(10.5,count(mult(a,c)))))
 
-As a whole, this is a reduced mapping Function. `div` is a reduced mapping function since it is a <<analytics-mapping-functions.adoc#analytics-mapping-num-div,provided mapping function>> and has reduced arguments.
+As a whole, this is a reduced mapping Function. `div` is a reduced mapping function since it is a <<analytics-mapping-functions.adoc#division,provided mapping function>> and has reduced arguments.
 
 If we break down the expression further:
 
 * `sum(a,fill_missing(b,0))`: Reduction Function +
-`sum` is a <<analytics-reduction-functions.adoc#analytics-reduction-sum,provided reduction function>>.
+`sum` is a <<analytics-reduction-functions.adoc#sum,provided reduction function>>.
 ** `a`: a Field
 ** `fill_missing(b,0)`: Unreduced Mapping Function +
-`fill_missing` is an unreduced mapping function since it is a <<analytics-mapping-functions.adoc#analytics-mapping-cond-fill_missing,provided mapping function>> and has a field argument.
+`fill_missing` is an unreduced mapping function since it is a <<analytics-mapping-functions.adoc#fill-missing,provided mapping function>> and has a field argument.
 *** `b`: Field
 *** `0`: Constant
 
 * `add(10.5,count(mult(a,mult(b,c))))`: Reduced Mapping Function +
-`add` is a reduced mapping function since it is a <<analytics-mapping-functions.adoc#analytics-mapping-num-add,provided mapping function>> and has a reduction function argument.
+`add` is a reduced mapping function since it is a <<analytics-mapping-functions.adoc#addition,provided mapping function>> and has a reduction function argument.
 ** `10.5`: Constant
 ** `count(mult(a,c))`: Reduction Function +
-`count` is a  <<analytics-reduction-functions.adoc#analytics-reduction-count,provided reduction function>>
+`count` is a  <<analytics-reduction-functions.adoc#count,provided reduction function>>
 *** `mult(a,c)`: Unreduced Mapping Function +
-`mult` is an unreduced mapping function since it is a <<analytics-mapping-functions.adoc#analytics-mapping-num-mult,provided mapping function>> and has two field arguments.
+`mult` is an unreduced mapping function since it is a <<analytics-mapping-functions.adoc#multiplication,provided mapping function>> and has two field arguments.
 **** `a`: Field
 **** `c`: Field
 
@@ -242,39 +242,39 @@ All single-valued expressions can be treated as multi-valued expressions that co
 Single-valued expressions and multi-valued expressions can be used together in many mapping functions, as well as multi-valued expressions being used alone, and many single-valued expressions being used together. For example:
 
 `add(<single-valued double>, <single-valued double>, ...)`::
-Returns a *single-valued* double expression where the value of the values of each expression are added.
+Returns a single-valued double expression where the value of the values of each expression are added.
 
 `add(<single-valued double>, <multi-valued double>)`::
-Returns a *multi-valued* double expression where each value of the second expression is added to the single value of the first expression.
+Returns a multi-valued double expression where each value of the second expression is added to the single value of the first expression.
 
-`add(<multi-valued double>*, <single-valued double>)`::
+`add(<multi-valued double>, <single-valued double>)`::
 Acts the same as the above function.
 
 `add(<multi-valued double>)`::
-    Returns a *single-valued* double expression which is the sum of the multiple values of the parameter expression.
+    Returns a single-valued double expression which is the sum of the multiple values of the parameter expression.
 
 === Types and Implicit Casting
 
 The new analytics component currently supports the types listed in the below table.
 These types have one-way implicit casting enabled for the following relationships:
 
-[cols="20,80",options="header"]
+[cols="20s,80",options="header"]
 |===
 | Type | Implicitly Casts To
-| *Boolean* | String
-| *Date* | Long, String
-| *Integer* | Long, Float, Double, String
-| *Long* | Double, String
-| *Float* | Double, String
-| *Double* | String
-| *String* | _none_
+| Boolean | String
+| Date | Long, String
+| Integer | Long, Float, Double, String
+| Long | Double, String
+| Float | Double, String
+| Double | String
+| String | _none_
 |===
 
 An implicit cast means that if a function requires a certain type of value as a parameter, arguments will be automatically converted to that type if it is possible.
 
 For example, `concat()` only accepts string parameters and since all types can be implicitly cast to strings, any type is accepted as an argument.
 
-This also goes for dynamically typed functions. `fillmissing()` requires two arguments of the same type. However, two types that implicitly cast to the same type can also be used.
+This also goes for dynamically typed functions. `fill_missing()` requires two arguments of the same type. However, two types that implicitly cast to the same type can also be used.
 
 For example, `fill_missing(<long>,<float>)` will be cast to `fill_missing(<double>,<double>)` since long cannot be cast to float and float cannot be cast to long implicitly.
 
@@ -595,8 +595,7 @@ The second pivot given will be treated like one value facet for each value of th
 Each of these second-level value facets will be limited to the documents in their first-level facet bucket.
 This continues for however many pivots are provided.
 
-Sorting is enabled on a per-pivot basis. This means that if your top pivot has a sort with `limit:1`, then only that first
-value of the facet will be drilled down into. Sorting in each pivot is independent of the other pivots.
+Sorting is enabled on a per-pivot basis. This means that if your top pivot has a sort with `limit:1`, then only that first value of the facet will be drilled down into. Sorting in each pivot is independent of the other pivots.
 
 [source,json]
 .Example Pivot Facet Request
@@ -671,7 +670,7 @@ The `sort` parameter within the pivot object is optional, and can be given in an
 === Analytic Range Facets
 
 Range Facets are used to group documents by the value of a field into a given set of ranges.
-The inputs for analytics Range Facets are identical to those used for Solr Range Facets.
+The inputs for analytics range facets are identical to those used for Solr range facets.
 Refer to the <<faceting.adoc#range-faceting,Range Facet documentation>> for questions regarding use.
 
 [source,json]
@@ -700,9 +699,12 @@ Refer to the <<faceting.adoc#range-faceting,Range Facet documentation>> for ques
 }
 ----
 
+// TODO need explanation of these parameters, even if they are also explained in Faceting docs
+// They are not identical - the names are different.
+
 [NOTE]
 .Optional Parameters
-The *hardend*, *include* and *others* parameters are all optional.
+The `hardend`, `include` and `others` parameters are all optional.
 
 [source,json]
 .Example Range Facet Response
@@ -751,6 +753,8 @@ The *hardend*, *include* and *others* parameters are all optional.
 
 Query Facets are used to group documents by given set of queries.
 
+// TODO need explanation of parameters
+
 [source,json]
 .Example Query Facet Request
 ----


Mime
View raw message