Merge branch 'master' into plot_pca

* master:
  refactor: Rename Variable where we make the roles of the objects clearer in the tests.
  test: clarified the name of a test.
  fix: corrected a comment.
  test: clarified naming using domain language (repeated roots).
  fix: corrected the comment.
  test: added some interesting and missing tests.
  test: changed the example and added a comment to make it clear what the coefficients correspond to.
  test: added a simple test for x^2 + 2x + 1, whose roots are x = -1 and -1
  refactor: Rename Variable - it looks like it is a root.
  stylg: removed redundant comment.
  refactor: Rename Method, and now we have the interface that a client (in this case the test) needs.
  refactor: Inline Method as it has no clients.
  style: corrected a Smalltalk code critique.
  refactor: clarified the name of the method.
  refactor: Inline Method, as it has no clients.
  refactor: Move Method to a more sensible place.
  refactor: made the method a class method. Next we can inline the instance method.
  refactor: Extract Method where a method instantiates a root finding algorithm with the desired precision.
  refactor: migrated the client to no longer use roots message.
  refactor: using Parallel Change, introduced a new message that returns roots in order.

src/Math-Numerical/PMNewtonZeroFinder.class.st

@@ -39,6 +39,15 @@ PMNewtonZeroFinder class >> function: aBlock1 derivative: aBlock2 [
 	^(self new) setFunction: aBlock1; setDerivative: aBlock2; yourself
 ]
 
+{ #category : #information }
+PMNewtonZeroFinder class >> with: precision [
+
+	| rootFinder |
+	rootFinder := self new.
+	rootFinder desiredPrecision: precision.
+	^ rootFinder
+]
+
 { #category : #operation }
 PMNewtonZeroFinder >> computeInitialValues [
 	"Private - If no derivative has been defined, take an ad-hoc definition.

src/Math-Polynomials/PMPolynomial.class.st

@@ -233,27 +233,27 @@ PMPolynomial >> reciprocal [
 
 { #category : #information }
 PMPolynomial >> roots [
-
-	^ self roots: Float defaultComparisonPrecision
+		^ (self roots: Float defaultComparisonPrecision) asSortedCollection asArray
 ]
 
 { #category : #information }
 PMPolynomial >> roots: aNumber [
 
-	| pol roots x rootFinder |
-	rootFinder := PMNewtonZeroFinder new.
-	rootFinder desiredPrecision: aNumber.
-	pol := self class coefficients: ( coefficients reverse collect: [ :each | each asFloat]).
+	| pol roots root rootFinder |
+	rootFinder := PMNewtonZeroFinder with: aNumber.
+	pol := self class coefficients:
+		       (coefficients reverse collect: [ :each | each asFloat ]).
 	roots := OrderedCollection new: self degree.
-	[ rootFinder setFunction: pol; setDerivative: pol derivative.
-	  x := rootFinder evaluate.
-	  rootFinder hasConverged
-		] whileTrue: [ roots add: x.
-					   pol := pol deflatedAt: x.
-					   pol degree > 0
-						 ifFalse: [ ^roots].
-					 ].
-	^roots
+	[
+	rootFinder
+		setFunction: pol;
+		setDerivative: pol derivative.
+	root := rootFinder evaluate.
+	rootFinder hasConverged ] whileTrue: [
+		roots add: root.
+		pol := pol deflatedAt: root.
+		pol degree > 0 ifFalse: [ ^ roots ] ].
+	^ roots
 ]
 
 { #category : #'double dispatching' }

src/Math-Tests-Polynomials/PMPolynomialTest.class.st

@@ -235,13 +235,36 @@ PMPolynomialTest >> testPolynomialRoots [
 
 	| polynomial roots |
 	polynomial := PMPolynomial coefficients: #( -10 -13 -2 1 ).
-	roots := polynomial roots asSortedCollection asArray.
+	roots := polynomial roots .
 	self assert: roots size equals: 3.
 	self assert: (roots at: 1) + 2 closeTo: 0.
 	self assert: (roots at: 2) + 1 closeTo: 0.
 	self assert: (roots at: 3) - 5 closeTo: 0
 ]
 
+{ #category : #'iterative algorithms' }
+PMPolynomialTest >> testPolynomialRootsConstantsHaveNoRoots [
+
+	| constant |
+	"Here, compute the roots of the constant C = 1"
+	constant := PMPolynomial coefficients: #( 1 ).
+	self
+		should: [ constant roots ]
+		raise: Error
+		description: 'Function''s derivative seems to be zero everywhere'
+]
+
+{ #category : #'iterative algorithms' }
+PMPolynomialTest >> testPolynomialRootsForLinear [
+
+	| linearPolynomial roots |
+	"Here, compute the roots of the linear (2x + 1)"
+	linearPolynomial := PMPolynomial coefficients: #( 1 2 ).
+	roots := linearPolynomial roots.
+	self assert: roots size equals: 1.
+	self assert: (roots at: 1) closeTo: -0.5
+]
+
 { #category : #'function evaluation' }
 PMPolynomialTest >> testPolynomialSubtraction [
 	| polynomial |
@@ -253,3 +276,14 @@ PMPolynomialTest >> testPolynomialSubtraction [
 	self assert: (polynomial at: 3) equals: -1.
 	self assert: (polynomial at: 4) equals: 0
 ]
+
+{ #category : #'iterative algorithms' }
+PMPolynomialTest >> testPolynomialWithRepeatedRoots [
+	| polynomialWithRepeatedRoots roots |
+	"Here, compute the roots of the quadratic (2x + 1)^2 = 4 x^2 + 4 x + 1"
+	polynomialWithRepeatedRoots := PMPolynomial coefficients: #(1 4 4).
+	roots := polynomialWithRepeatedRoots roots .
+	self assert: roots size equals: 2.
+	self assert: (roots at: 1) closeTo: -0.5 .
+	self assert: (roots at: 2) closeTo: -0.5 .
+]