You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by kw...@apache.org on 2018/03/27 23:06:08 UTC
[1/2] lucene-solr:master: LUCENE-8227: Handle identical planes
properly in GeoComplexPolygon.
Repository: lucene-solr
Updated Branches:
refs/heads/master ade2cf2e7 -> b151b2ccf
LUCENE-8227: Handle identical planes properly in GeoComplexPolygon.
Project: http://git-wip-us.apache.org/repos/asf/lucene-solr/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucene-solr/commit/6dcb6ae6
Tree: http://git-wip-us.apache.org/repos/asf/lucene-solr/tree/6dcb6ae6
Diff: http://git-wip-us.apache.org/repos/asf/lucene-solr/diff/6dcb6ae6
Branch: refs/heads/master
Commit: 6dcb6ae64155921ffb2841732844c9b8776968bd
Parents: 07d255a
Author: Karl Wright <Da...@gmail.com>
Authored: Tue Mar 27 19:05:27 2018 -0400
Committer: Karl Wright <Da...@gmail.com>
Committed: Tue Mar 27 19:05:27 2018 -0400
----------------------------------------------------------------------
.../spatial3d/geom/GeoComplexPolygon.java | 109 +++++++++++--------
1 file changed, 63 insertions(+), 46 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/6dcb6ae6/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoComplexPolygon.java
----------------------------------------------------------------------
diff --git a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoComplexPolygon.java b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoComplexPolygon.java
index da99d50..de12348 100644
--- a/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoComplexPolygon.java
+++ b/lucene/spatial3d/src/java/org/apache/lucene/spatial3d/geom/GeoComplexPolygon.java
@@ -1017,19 +1017,26 @@ class GeoComplexPolygon extends GeoBasePolygon {
private void countCrossingPoint(final GeoPoint crossingPoint, final Edge edge) {
if (crossingPoint.isNumericallyIdentical(edge.startPoint)) {
+
+ // The crossing point is shared by two edges. If we are going to count it, this is the edge we'll count it on.
// We have to figure out if this crossing should be counted.
+ // We look at the above plane and the below plane and see if we cross either of them.
+ // If we cross NEITHER of them: we're in the "zone" between the planes, and this edge doesn't count.
+
// Does the crossing for this edge go up, or down? Or can't we tell?
- final GeoPoint[] aboveIntersections = abovePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
- final GeoPoint[] belowIntersections = belowPlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
-
- assert !(aboveIntersections.length > 0 && belowIntersections.length > 0) : "edge that ends in a crossing can't both up and down";
-
- if (aboveIntersections.length == 0 && belowIntersections.length == 0) {
+ final GeoPoint[] aboveIntersections = abovePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
+ final GeoPoint[] belowIntersections = belowPlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
+
+ if ((aboveIntersections == null || aboveIntersections.length == 0) && (belowIntersections == null || belowIntersections.length == 0)) {
return;
}
-
- final boolean edgeCrossesAbove = aboveIntersections.length > 0;
+
+ // A null value means we have a situation where the edge is numerically identical. That's not counted as a "crossing".
+
+ assert !(aboveIntersections != null && aboveIntersections.length > 0 && belowIntersections != null && belowIntersections.length > 0) : "edge that ends in a crossing can't be both up and down!";
+
+ final boolean edgeCrossesAbove = aboveIntersections != null && aboveIntersections.length > 0;
// This depends on the previous edge that first departs from identicalness.
Edge assessEdge = edge;
@@ -1037,12 +1044,10 @@ class GeoComplexPolygon extends GeoBasePolygon {
GeoPoint[] assessBelowIntersections;
while (true) {
assessEdge = assessEdge.previous;
- assessAboveIntersections = abovePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
- assessBelowIntersections = belowPlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
-
- assert !(assessAboveIntersections.length > 0 && assessBelowIntersections.length > 0) : "assess edge that ends in a crossing can't both up and down";
+ assessAboveIntersections = abovePlane.findCrossings(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
+ assessBelowIntersections = belowPlane.findCrossings(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
- if (assessAboveIntersections.length == 0 && assessBelowIntersections.length == 0) {
+ if ((assessAboveIntersections == null || assessAboveIntersections.length == 0) && (assessBelowIntersections == null || assessBelowIntersections.length == 0)) {
continue;
}
break;
@@ -1073,7 +1078,7 @@ class GeoComplexPolygon extends GeoBasePolygon {
// point where they hit the plane. This may be complicated by the 3D geometry; it may not be safe just to look at the endpoints of the edges
// and make an assessment that way, since a single edge can intersect the plane at more than one point.
- final boolean assessEdgeAbove = assessAboveIntersections.length > 0;
+ final boolean assessEdgeAbove = assessAboveIntersections != null && assessAboveIntersections.length > 0;
if (assessEdgeAbove != edgeCrossesAbove) {
crossingCount++;
}
@@ -1082,16 +1087,14 @@ class GeoComplexPolygon extends GeoBasePolygon {
// Figure out if the crossing should be counted.
// Does the crossing for this edge go up, or down? Or can't we tell?
- final GeoPoint[] aboveIntersections = abovePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
- final GeoPoint[] belowIntersections = belowPlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
-
- assert !(aboveIntersections.length > 0 && belowIntersections.length > 0) : "edge that ends in a crossing can't both up and down";
+ final GeoPoint[] aboveIntersections = abovePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
+ final GeoPoint[] belowIntersections = belowPlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
- if (aboveIntersections.length == 0 && belowIntersections.length == 0) {
+ if ((aboveIntersections == null || aboveIntersections.length == 0) && (belowIntersections == null || belowIntersections.length == 0)) {
return;
}
- final boolean edgeCrossesAbove = aboveIntersections.length > 0;
+ final boolean edgeCrossesAbove = aboveIntersections != null && aboveIntersections.length > 0;
// This depends on the previous edge that first departs from identicalness.
Edge assessEdge = edge;
@@ -1099,12 +1102,10 @@ class GeoComplexPolygon extends GeoBasePolygon {
GeoPoint[] assessBelowIntersections;
while (true) {
assessEdge = assessEdge.next;
- assessAboveIntersections = abovePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
- assessBelowIntersections = belowPlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
-
- assert !(assessAboveIntersections.length > 0 && assessBelowIntersections.length > 0) : "assess edge that ends in a crossing can't both up and down";
+ assessAboveIntersections = abovePlane.findCrossings(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
+ assessBelowIntersections = belowPlane.findCrossings(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
- if (assessAboveIntersections.length == 0 && assessBelowIntersections.length == 0) {
+ if (assessAboveIntersections != null && assessAboveIntersections.length == 0 && assessBelowIntersections != null && assessBelowIntersections.length == 0) {
continue;
}
break;
@@ -1121,7 +1122,7 @@ class GeoComplexPolygon extends GeoBasePolygon {
// point where they hit the plane. This may be complicated by the 3D geometry; it may not be safe just to look at the endpoints of the edges
// and make an assessment that way, since a single edge can intersect the plane at more than one point.
- final boolean assessEdgeAbove = assessAboveIntersections.length > 0;
+ final boolean assessEdgeAbove = assessAboveIntersections != null && assessAboveIntersections.length > 0;
if (assessEdgeAbove != edgeCrossesAbove) {
crossingCount++;
}
@@ -1326,14 +1327,15 @@ class GeoComplexPolygon extends GeoBasePolygon {
computeInsideOutside();
// Does the crossing for this edge go up, or down? Or can't we tell?
- final GeoPoint[] insideTestPointPlaneIntersections = testPointInsidePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane, insideTestPointCutoffPlane);
- final GeoPoint[] insideTravelPlaneIntersections = travelInsidePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane, insideTravelCutoffPlane);
- final GeoPoint[] outsideTestPointPlaneIntersections = testPointOutsidePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
- final GeoPoint[] outsideTravelPlaneIntersections = travelOutsidePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
+ final GeoPoint[] insideTestPointPlaneIntersections = testPointInsidePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane, insideTestPointCutoffPlane);
+ final GeoPoint[] insideTravelPlaneIntersections = travelInsidePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane, insideTravelCutoffPlane);
+ final GeoPoint[] outsideTestPointPlaneIntersections = testPointOutsidePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
+ final GeoPoint[] outsideTravelPlaneIntersections = travelOutsidePlane.findCrossings(planetModel, edge.plane, edge.startPlane, edge.endPlane);
- assert !(insideTestPointPlaneIntersections.length + insideTravelPlaneIntersections.length > 0 && outsideTestPointPlaneIntersections.length + outsideTravelPlaneIntersections.length > 0) : "edge that ends in a crossing can't both up and down";
-
- if (insideTestPointPlaneIntersections.length + insideTravelPlaneIntersections.length == 0 && outsideTestPointPlaneIntersections.length + outsideTravelPlaneIntersections.length == 0) {
+ if ((insideTestPointPlaneIntersections == null || insideTestPointPlaneIntersections.length == 0) &&
+ (insideTravelPlaneIntersections == null || insideTravelPlaneIntersections.length == 0) &&
+ (outsideTestPointPlaneIntersections == null || outsideTestPointPlaneIntersections.length == 0) &&
+ (outsideTravelPlaneIntersections == null || outsideTravelPlaneIntersections.length == 0)) {
//System.err.println(" No inside or outside crossings found");
return;
}
@@ -1353,10 +1355,12 @@ class GeoComplexPolygon extends GeoBasePolygon {
assessOutsideTestPointIntersections = testPointOutsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
assessOutsideTravelIntersections = travelOutsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
- // An edge can cross both outside and inside, because of the corner. But it can be considered to cross the inside ONLY if it crosses either of the inside edges.
- //assert !(assessInsideTestPointIntersections.length + assessInsideTravelIntersections.length > 0 && assessOutsideTestPointIntersections.length + assessOutsideTravelIntersections.length > 0) : "assess edge that ends in a crossing can't both up and down";
-
- if (assessInsideTestPointIntersections.length + assessInsideTravelIntersections.length == 0 && assessOutsideTestPointIntersections.length + assessOutsideTravelIntersections.length == 0) {
+ // If the assess edge is numerically identical to the edge we're trying to find the intersections with, there's not really a crossing, so count it as zero.
+
+ if ((assessInsideTestPointIntersections == null || assessInsideTestPointIntersections.length == 0) &&
+ (assessInsideTravelIntersections == null || assessInsideTravelIntersections.length == 0) &&
+ (assessOutsideTestPointIntersections == null || assessOutsideTestPointIntersections.length == 0) &&
+ (assessOutsideTravelIntersections == null || assessOutsideTravelIntersections.length == 0)) {
continue;
}
break;
@@ -1376,7 +1380,12 @@ class GeoComplexPolygon extends GeoBasePolygon {
} else {
otherCrossingPoints = testPointPlane.findCrossings(planetModel, assessEdge.plane, testPointCutoffPlane, testPointOtherCutoffPlane, assessEdge.startPlane, assessEdge.endPlane);
}
-
+
+ if (otherCrossingPoints == null) {
+ // The assessEdge plane is the same as the travel plane. We consider this the same as "no crossing".
+ return;
+ }
+
// Look for a matching endpoint. If the other endpoint doesn't show up, it is either out of bounds (in which case the
// transition won't be counted for that edge), or it is not a crossing for that edge (so, same conclusion).
for (final GeoPoint otherCrossingPoint : otherCrossingPoints) {
@@ -1393,7 +1402,8 @@ class GeoComplexPolygon extends GeoBasePolygon {
// point where they hit the plane. This may be complicated by the 3D geometry; it may not be safe just to look at the endpoints of the edges
// and make an assessment that way, since a single edge can intersect the plane at more than one point.
- final boolean assessEdgeInside = assessInsideTestPointIntersections.length + assessInsideTravelIntersections.length > 0;
+ final boolean assessEdgeInside = (assessInsideTestPointIntersections != null && assessInsideTestPointIntersections.length > 0) ||
+ (assessInsideTravelIntersections != null && assessInsideTravelIntersections.length > 0);
if (assessEdgeInside != edgeCrossesInside) {
//System.err.println(" Incrementing crossing count");
crossingCount++;
@@ -1405,6 +1415,8 @@ class GeoComplexPolygon extends GeoBasePolygon {
//System.err.println(" Crossing point = edge.endPoint");
// Figure out if the crossing should be counted.
computeInsideOutside();
+
+ // If the assess edge is numerically identical to the edge we're trying to find the intersections with, there's not really a crossing, so count it as zero.
// Does the crossing for this edge go up, or down? Or can't we tell?
final GeoPoint[] insideTestPointPlaneIntersections = testPointInsidePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane, insideTestPointCutoffPlane);
@@ -1413,14 +1425,17 @@ class GeoComplexPolygon extends GeoBasePolygon {
final GeoPoint[] outsideTravelPlaneIntersections = travelOutsidePlane.findIntersections(planetModel, edge.plane, edge.startPlane, edge.endPlane);
// An edge can cross both outside and inside, because of the corner. But it can be considered to cross the inside ONLY if it crosses either of the inside edges.
- //assert !(insideTestPointPlaneIntersections.length + insideTravelPlaneIntersections.length > 0 && outsideTestPointPlaneIntersections.length + outsideTravelPlaneIntersections.length > 0) : "edge that ends in a crossing can't go both up and down: insideTestPointPlaneIntersections: "+insideTestPointPlaneIntersections.length+" insideTravelPlaneIntersections: "+insideTravelPlaneIntersections.length+" outsideTestPointPlaneIntersections: "+outsideTestPointPlaneIntersections.length+" outsideTravelPlaneIntersections: "+outsideTravelPlaneIntersections.length;
- if (insideTestPointPlaneIntersections.length + insideTravelPlaneIntersections.length == 0 && outsideTestPointPlaneIntersections.length + outsideTravelPlaneIntersections.length == 0) {
+ if ((insideTestPointPlaneIntersections == null || insideTestPointPlaneIntersections.length == 0) &&
+ (insideTravelPlaneIntersections == null || insideTravelPlaneIntersections.length == 0) &&
+ (outsideTestPointPlaneIntersections == null || outsideTestPointPlaneIntersections.length == 0) &&
+ (outsideTravelPlaneIntersections == null || outsideTravelPlaneIntersections.length == 0)) {
//System.err.println(" No inside or outside crossings found");
return;
}
- final boolean edgeCrossesInside = insideTestPointPlaneIntersections.length + insideTravelPlaneIntersections.length > 0;
+ final boolean edgeCrossesInside = (insideTestPointPlaneIntersections !=null && insideTestPointPlaneIntersections.length > 0) ||
+ (insideTravelPlaneIntersections != null && insideTravelPlaneIntersections.length > 0);
// This depends on the previous edge that first departs from identicalness.
Edge assessEdge = edge;
@@ -1435,9 +1450,10 @@ class GeoComplexPolygon extends GeoBasePolygon {
assessOutsideTestPointIntersections = testPointOutsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
assessOutsideTravelIntersections = travelOutsidePlane.findIntersections(planetModel, assessEdge.plane, assessEdge.startPlane, assessEdge.endPlane);
- assert !(assessInsideTestPointIntersections.length + assessInsideTravelIntersections.length > 0 && assessOutsideTestPointIntersections.length + assessOutsideTravelIntersections.length > 0) : "assess edge that ends in a crossing can't both up and down";
-
- if (assessInsideTestPointIntersections.length + assessInsideTravelIntersections.length == 0 && assessOutsideTestPointIntersections.length + assessOutsideTravelIntersections.length == 0) {
+ if ((assessInsideTestPointIntersections == null || assessInsideTestPointIntersections.length == 0) &&
+ (assessInsideTravelIntersections == null || assessInsideTravelIntersections.length == 0) &&
+ (assessOutsideTestPointIntersections == null || assessOutsideTestPointIntersections.length == 0) &&
+ (assessOutsideTravelIntersections == null || assessOutsideTravelIntersections.length == 0)) {
continue;
}
break;
@@ -1454,7 +1470,8 @@ class GeoComplexPolygon extends GeoBasePolygon {
// point where they hit the plane. This may be complicated by the 3D geometry; it may not be safe just to look at the endpoints of the edges
// and make an assessment that way, since a single edge can intersect the plane at more than one point.
- final boolean assessEdgeInside = assessInsideTestPointIntersections.length + assessInsideTravelIntersections.length > 0;
+ final boolean assessEdgeInside = (assessInsideTestPointIntersections !=null && assessInsideTestPointIntersections.length > 0) ||
+ (assessInsideTravelIntersections != null && assessInsideTravelIntersections.length > 0);
if (assessEdgeInside != edgeCrossesInside) {
//System.err.println(" Incrementing crossing count");
crossingCount++;
[2/2] lucene-solr:master: Merge branch 'master' of
https://git-wip-us.apache.org/repos/asf/lucene-solr
Posted by kw...@apache.org.
Merge branch 'master' of https://git-wip-us.apache.org/repos/asf/lucene-solr
Project: http://git-wip-us.apache.org/repos/asf/lucene-solr/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucene-solr/commit/b151b2cc
Tree: http://git-wip-us.apache.org/repos/asf/lucene-solr/tree/b151b2cc
Diff: http://git-wip-us.apache.org/repos/asf/lucene-solr/diff/b151b2cc
Branch: refs/heads/master
Commit: b151b2ccfed8bcc9de0f6d046fa0fb2a15360285
Parents: 6dcb6ae ade2cf2
Author: Karl Wright <Da...@gmail.com>
Authored: Tue Mar 27 19:05:40 2018 -0400
Committer: Karl Wright <Da...@gmail.com>
Committed: Tue Mar 27 19:05:40 2018 -0400
----------------------------------------------------------------------
dev-tools/eclipse/run-solr-cloud.launch | 2 +-
dev-tools/eclipse/run-solr.launch | 2 +-
dev-tools/scripts/buildAndPushRelease.py | 12 +-
dev-tools/scripts/smokeTestRelease.py | 4 +-
lucene/CHANGES.txt | 6 +
.../lucene/analysis/util/UnicodeProps.java | 6 +-
lucene/analysis/icu/src/data/uax29/Default.rbbi | 96 ++-
.../icu/src/data/utr30/DiacriticFolding.txt | 11 +-
.../icu/src/data/utr30/NativeDigitFolding.txt | 10 +
lucene/analysis/icu/src/data/utr30/nfc.txt | 13 +-
lucene/analysis/icu/src/data/utr30/nfkc.txt | 4 +-
lucene/analysis/icu/src/data/utr30/nfkc_cf.txt | 10 +-
.../icu/segmentation/BreakIteratorWrapper.java | 190 ++----
.../segmentation/CompositeBreakIterator.java | 2 +-
.../segmentation/DefaultICUTokenizerConfig.java | 18 +-
.../analysis/icu/segmentation/ICUTokenizer.java | 8 +-
.../icu/segmentation/ICUTokenizerConfig.java | 9 +-
.../icu/segmentation/ICUTokenizerFactory.java | 4 +-
lucene/analysis/icu/src/java/overview.html | 2 +-
.../analysis/icu/segmentation/Default.brk | Bin 36768 -> 50760 bytes
.../icu/segmentation/MyanmarSyllable.brk | Bin 20744 -> 21272 bytes
.../org/apache/lucene/analysis/icu/utr30.nrm | Bin 55184 -> 59056 bytes
.../icu/segmentation/TestICUTokenizer.java | 99 ++-
.../icu/segmentation/TestICUTokenizerCJK.java | 9 +
.../analysis/icu/GenerateUTR30DataFiles.java | 6 +-
.../classification/BM25NBClassifierTest.java | 11 +-
.../BooleanPerceptronClassifierTest.java | 11 +-
.../CachingNaiveBayesClassifierTest.java | 11 +-
.../KNearestFuzzyClassifierTest.java | 12 +-
.../KNearestNeighborClassifierTest.java | 12 +-
.../SimpleNaiveBayesClassifierTest.java | 11 +-
lucene/common-build.xml | 6 +
.../analysis/standard/StandardTokenizer.java | 5 +-
lucene/ivy-versions.properties | 8 +-
lucene/licenses/icu4j-59.1.jar.sha1 | 1 -
lucene/licenses/icu4j-61.1.jar.sha1 | 1 +
.../analysis/BaseTokenStreamTestCase.java | 93 ++-
solr/CHANGES.txt | 20 +-
solr/bin/solr | 15 +-
solr/bin/solr.cmd | 23 +-
solr/contrib/ltr/src/test-files/log4j2.xml | 1 -
.../prometheus-exporter/bin/solr-exporter | 2 +-
.../prometheus-exporter/bin/solr-exporter.cmd | 2 +-
.../prometheus-exporter/conf/log4j.properties | 22 -
.../contrib/prometheus-exporter/conf/log4j2.xml | 53 ++
solr/contrib/prometheus-exporter/ivy.xml | 2 +-
.../src/test-files/conf/log4j.properties | 22 -
.../src/test-files/conf/log4j2.xml | 35 +
.../client/solrj/embedded/JettySolrRunner.java | 2 +-
.../org/apache/solr/cloud/ZkController.java | 21 +-
.../processor/AtomicUpdateProcessorFactory.java | 2 +-
.../src/java/org/apache/solr/util/TimeOut.java | 9 +-
.../org/apache/solr/cloud/ZkControllerTest.java | 85 ++-
.../AtomicUpdateProcessorFactoryTest.java | 4 +-
solr/example/resources/log4j2.xml | 7 +-
solr/licenses/icu4j-59.1.jar.sha1 | 1 -
solr/licenses/icu4j-61.1.jar.sha1 | 1 +
solr/server/resources/log4j2.xml | 7 +-
solr/server/scripts/cloud-scripts/log4j2.xml | 2 +-
solr/solr-ref-guide/src/_config.yml.template | 2 +-
solr/solr-ref-guide/src/cdcr-architecture.adoc | 2 +-
.../solr-ref-guide/src/configuring-logging.adoc | 6 +-
solr/solr-ref-guide/src/curve-fitting.adoc | 182 +++++
solr/solr-ref-guide/src/highlighting.adoc | 2 +
solr/solr-ref-guide/src/json-facet-api.adoc | 9 +-
solr/solr-ref-guide/src/machine-learning.adoc | 680 +++++++++++++++++++
solr/solr-ref-guide/src/math-expressions.adoc | 59 ++
solr/solr-ref-guide/src/matrix-math.adoc | 443 ++++++++++++
solr/solr-ref-guide/src/numerical-analysis.adoc | 430 ++++++++++++
solr/solr-ref-guide/src/other-parsers.adoc | 78 ++-
.../src/parallel-sql-interface.adoc | 2 +-
.../src/probability-distributions.adoc | 415 +++++++++++
solr/solr-ref-guide/src/regression.adoc | 439 ++++++++++++
solr/solr-ref-guide/src/scalar-math.adoc | 137 ++++
solr/solr-ref-guide/src/simulations.adoc | 213 ++++++
.../src/statistical-programming.adoc | 4 +-
solr/solr-ref-guide/src/statistics.adoc | 575 ++++++++++++++++
.../src/streaming-expressions.adoc | 2 +-
solr/solr-ref-guide/src/term-vectors.adoc | 237 +++++++
solr/solr-ref-guide/src/time-series.adoc | 431 ++++++++++++
solr/solr-ref-guide/src/variables.adoc | 147 ++++
solr/solr-ref-guide/src/vector-math.adoc | 343 ++++++++++
solr/solr-ref-guide/src/vectorization.adoc | 243 +++++++
.../solrj/io/eval/FieldValueEvaluator.java | 24 +-
solr/solrj/src/test-files/log4j2.xml | 2 +-
solr/test-framework/src/test-files/log4j2.xml | 2 +-
86 files changed, 5668 insertions(+), 484 deletions(-)
----------------------------------------------------------------------