Merge pull request #6360 from jonathanunderwood/legfit_restrict_terms

ENH: Allow specification of terms to fit in polynomial fitting functions

7 files changed, 176 insertions, 0 deletions

diff --git a/numpy/polynomial/tests/test_chebyshev.py b/numpy/polynomial/tests/test_chebyshev.py
index a596905f6..8d992c4f0 100644
--- a/numpy/polynomial/tests/test_chebyshev.py
+++ b/numpy/polynomial/tests/test_chebyshev.py
@@ -399,6 +399,9 @@ class TestFitting(TestCase):
         def f(x):
             return x*(x - 1)*(x - 2)
 
+        def f2(x):
+            return x**4 + x**2 + 1
+
         # Test exceptions
         assert_raises(ValueError, cheb.chebfit, [1], [1], -1)
         assert_raises(TypeError, cheb.chebfit, [[1]], [1], 0)
@@ -408,6 +411,9 @@ class TestFitting(TestCase):
         assert_raises(TypeError, cheb.chebfit, [1], [1, 2], 0)
         assert_raises(TypeError, cheb.chebfit, [1], [1], 0, w=[[1]])
         assert_raises(TypeError, cheb.chebfit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, cheb.chebfit, [1], [1], [-1,])
+        assert_raises(ValueError, cheb.chebfit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, cheb.chebfit, [1], [1], [])
 
         # Test fit
         x = np.linspace(0, 2)
@@ -416,13 +422,25 @@ class TestFitting(TestCase):
         coef3 = cheb.chebfit(x, y, 3)
         assert_equal(len(coef3), 4)
         assert_almost_equal(cheb.chebval(x, coef3), y)
+        coef3 = cheb.chebfit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(cheb.chebval(x, coef3), y)
         #
         coef4 = cheb.chebfit(x, y, 4)
         assert_equal(len(coef4), 5)
         assert_almost_equal(cheb.chebval(x, coef4), y)
+        coef4 = cheb.chebfit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(cheb.chebval(x, coef4), y)
+        # check things still work if deg is not in strict increasing
+        coef4 = cheb.chebfit(x, y, [2, 3, 4, 1, 0])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(cheb.chebval(x, coef4), y)
         #
         coef2d = cheb.chebfit(x, np.array([y, y]).T, 3)
         assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = cheb.chebfit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
         # test weighting
         w = np.zeros_like(x)
         yw = y.copy()
@@ -430,13 +448,26 @@ class TestFitting(TestCase):
         y[0::2] = 0
         wcoef3 = cheb.chebfit(x, yw, 3, w=w)
         assert_almost_equal(wcoef3, coef3)
+        wcoef3 = cheb.chebfit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
         #
         wcoef2d = cheb.chebfit(x, np.array([yw, yw]).T, 3, w=w)
         assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = cheb.chebfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
         # test scaling with complex values x points whose square
         # is zero when summed.
         x = [1, 1j, -1, -1j]
         assert_almost_equal(cheb.chebfit(x, x, 1), [0, 1])
+        assert_almost_equal(cheb.chebfit(x, x, [0, 1]), [0, 1])
+        # test fitting only even polynomials
+        x = np.linspace(-1, 1)
+        y = f2(x)
+        coef1 = cheb.chebfit(x, y, 4)
+        assert_almost_equal(cheb.chebval(x, coef1), y)
+        coef2 = cheb.chebfit(x, y, [0, 2, 4])
+        assert_almost_equal(cheb.chebval(x, coef2), y)
+        assert_almost_equal(coef1, coef2)
 
 
 class TestCompanion(TestCase):
diff --git a/numpy/polynomial/tests/test_classes.py b/numpy/polynomial/tests/test_classes.py
index cd5a54687..a7cf7209c 100644
--- a/numpy/polynomial/tests/test_classes.py
+++ b/numpy/polynomial/tests/test_classes.py
@@ -173,11 +173,18 @@ def check_fit(Poly):
     assert_almost_equal(p(x), y)
     assert_almost_equal(p.domain, d)
     assert_almost_equal(p.window, w)
+    p = Poly.fit(x, y, [0, 1, 2, 3], domain=d, window=w)
+    assert_almost_equal(p(x), y)
+    assert_almost_equal(p.domain, d)
+    assert_almost_equal(p.window, w)
 
     # check with class domain default
     p = Poly.fit(x, y, 3, [])
     assert_equal(p.domain, Poly.domain)
     assert_equal(p.window, Poly.window)
+    p = Poly.fit(x, y, [0, 1, 2, 3], [])
+    assert_equal(p.domain, Poly.domain)
+    assert_equal(p.window, Poly.window)
 
     # check that fit accepts weights.
     w = np.zeros_like(x)
@@ -185,7 +192,9 @@ def check_fit(Poly):
     w[::2] = 1
     p1 = Poly.fit(x[::2], z[::2], 3)
     p2 = Poly.fit(x, z, 3, w=w)
+    p3 = Poly.fit(x, z, [0, 1, 2, 3], w=w)
     assert_almost_equal(p1(x), p2(x))
+    assert_almost_equal(p2(x), p3(x))
 
 
 def check_equal(Poly):
diff --git a/numpy/polynomial/tests/test_hermite.py b/numpy/polynomial/tests/test_hermite.py
index e67625a88..04da72b26 100644
--- a/numpy/polynomial/tests/test_hermite.py
+++ b/numpy/polynomial/tests/test_hermite.py
@@ -387,6 +387,9 @@ class TestFitting(TestCase):
         def f(x):
             return x*(x - 1)*(x - 2)
 
+        def f2(x):
+            return x**4 + x**2 + 1
+
         # Test exceptions
         assert_raises(ValueError, herm.hermfit, [1], [1], -1)
         assert_raises(TypeError, herm.hermfit, [[1]], [1], 0)
@@ -396,6 +399,9 @@ class TestFitting(TestCase):
         assert_raises(TypeError, herm.hermfit, [1], [1, 2], 0)
         assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[[1]])
         assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, herm.hermfit, [1], [1], [-1,])
+        assert_raises(ValueError, herm.hermfit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, herm.hermfit, [1], [1], [])
 
         # Test fit
         x = np.linspace(0, 2)
@@ -404,13 +410,25 @@ class TestFitting(TestCase):
         coef3 = herm.hermfit(x, y, 3)
         assert_equal(len(coef3), 4)
         assert_almost_equal(herm.hermval(x, coef3), y)
+        coef3 = herm.hermfit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(herm.hermval(x, coef3), y)
         #
         coef4 = herm.hermfit(x, y, 4)
         assert_equal(len(coef4), 5)
         assert_almost_equal(herm.hermval(x, coef4), y)
+        coef4 = herm.hermfit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(herm.hermval(x, coef4), y)
+        # check things still work if deg is not in strict increasing
+        coef4 = herm.hermfit(x, y, [2, 3, 4, 1, 0])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(herm.hermval(x, coef4), y)
         #
         coef2d = herm.hermfit(x, np.array([y, y]).T, 3)
         assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = herm.hermfit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
         # test weighting
         w = np.zeros_like(x)
         yw = y.copy()
@@ -418,13 +436,26 @@ class TestFitting(TestCase):
         y[0::2] = 0
         wcoef3 = herm.hermfit(x, yw, 3, w=w)
         assert_almost_equal(wcoef3, coef3)
+        wcoef3 = herm.hermfit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
         #
         wcoef2d = herm.hermfit(x, np.array([yw, yw]).T, 3, w=w)
         assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = herm.hermfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
         # test scaling with complex values x points whose square
         # is zero when summed.
         x = [1, 1j, -1, -1j]
         assert_almost_equal(herm.hermfit(x, x, 1), [0, .5])
+        assert_almost_equal(herm.hermfit(x, x, [0, 1]), [0, .5])
+        # test fitting only even Legendre polynomials
+        x = np.linspace(-1, 1)
+        y = f2(x)
+        coef1 = herm.hermfit(x, y, 4)
+        assert_almost_equal(herm.hermval(x, coef1), y)
+        coef2 = herm.hermfit(x, y, [0, 2, 4])
+        assert_almost_equal(herm.hermval(x, coef2), y)
+        assert_almost_equal(coef1, coef2)
 
 
 class TestCompanion(TestCase):
diff --git a/numpy/polynomial/tests/test_hermite_e.py b/numpy/polynomial/tests/test_hermite_e.py
index f8601a828..1162502dc 100644
--- a/numpy/polynomial/tests/test_hermite_e.py
+++ b/numpy/polynomial/tests/test_hermite_e.py
@@ -388,6 +388,9 @@ class TestFitting(TestCase):
         def f(x):
             return x*(x - 1)*(x - 2)
 
+        def f2(x):
+            return x**4 + x**2 + 1
+
         # Test exceptions
         assert_raises(ValueError, herme.hermefit, [1], [1], -1)
         assert_raises(TypeError, herme.hermefit, [[1]], [1], 0)
@@ -397,6 +400,9 @@ class TestFitting(TestCase):
         assert_raises(TypeError, herme.hermefit, [1], [1, 2], 0)
         assert_raises(TypeError, herme.hermefit, [1], [1], 0, w=[[1]])
         assert_raises(TypeError, herme.hermefit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, herme.hermefit, [1], [1], [-1,])
+        assert_raises(ValueError, herme.hermefit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, herme.hermefit, [1], [1], [])
 
         # Test fit
         x = np.linspace(0, 2)
@@ -405,13 +411,25 @@ class TestFitting(TestCase):
         coef3 = herme.hermefit(x, y, 3)
         assert_equal(len(coef3), 4)
         assert_almost_equal(herme.hermeval(x, coef3), y)
+        coef3 = herme.hermefit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(herme.hermeval(x, coef3), y)
         #
         coef4 = herme.hermefit(x, y, 4)
         assert_equal(len(coef4), 5)
         assert_almost_equal(herme.hermeval(x, coef4), y)
+        coef4 = herme.hermefit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(herme.hermeval(x, coef4), y)
+        # check things still work if deg is not in strict increasing
+        coef4 = herme.hermefit(x, y, [2, 3, 4, 1, 0])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(herme.hermeval(x, coef4), y)
         #
         coef2d = herme.hermefit(x, np.array([y, y]).T, 3)
         assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = herme.hermefit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
         # test weighting
         w = np.zeros_like(x)
         yw = y.copy()
@@ -419,13 +437,26 @@ class TestFitting(TestCase):
         y[0::2] = 0
         wcoef3 = herme.hermefit(x, yw, 3, w=w)
         assert_almost_equal(wcoef3, coef3)
+        wcoef3 = herme.hermefit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
         #
         wcoef2d = herme.hermefit(x, np.array([yw, yw]).T, 3, w=w)
         assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = herme.hermefit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
         # test scaling with complex values x points whose square
         # is zero when summed.
         x = [1, 1j, -1, -1j]
         assert_almost_equal(herme.hermefit(x, x, 1), [0, 1])
+        assert_almost_equal(herme.hermefit(x, x, [0, 1]), [0, 1])
+        # test fitting only even Legendre polynomials
+        x = np.linspace(-1, 1)
+        y = f2(x)
+        coef1 = herme.hermefit(x, y, 4)
+        assert_almost_equal(herme.hermeval(x, coef1), y)
+        coef2 = herme.hermefit(x, y, [0, 2, 4])
+        assert_almost_equal(herme.hermeval(x, coef2), y)
+        assert_almost_equal(coef1, coef2)
 
 
 class TestCompanion(TestCase):
diff --git a/numpy/polynomial/tests/test_laguerre.py b/numpy/polynomial/tests/test_laguerre.py
index 1dc57a960..c25476088 100644
--- a/numpy/polynomial/tests/test_laguerre.py
+++ b/numpy/polynomial/tests/test_laguerre.py
@@ -393,6 +393,9 @@ class TestFitting(TestCase):
         assert_raises(TypeError, lag.lagfit, [1], [1, 2], 0)
         assert_raises(TypeError, lag.lagfit, [1], [1], 0, w=[[1]])
         assert_raises(TypeError, lag.lagfit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, lag.lagfit, [1], [1], [-1,])
+        assert_raises(ValueError, lag.lagfit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, lag.lagfit, [1], [1], [])
 
         # Test fit
         x = np.linspace(0, 2)
@@ -401,13 +404,21 @@ class TestFitting(TestCase):
         coef3 = lag.lagfit(x, y, 3)
         assert_equal(len(coef3), 4)
         assert_almost_equal(lag.lagval(x, coef3), y)
+        coef3 = lag.lagfit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(lag.lagval(x, coef3), y)
         #
         coef4 = lag.lagfit(x, y, 4)
         assert_equal(len(coef4), 5)
         assert_almost_equal(lag.lagval(x, coef4), y)
+        coef4 = lag.lagfit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(lag.lagval(x, coef4), y)
         #
         coef2d = lag.lagfit(x, np.array([y, y]).T, 3)
         assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = lag.lagfit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
         # test weighting
         w = np.zeros_like(x)
         yw = y.copy()
@@ -415,13 +426,18 @@ class TestFitting(TestCase):
         y[0::2] = 0
         wcoef3 = lag.lagfit(x, yw, 3, w=w)
         assert_almost_equal(wcoef3, coef3)
+        wcoef3 = lag.lagfit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
         #
         wcoef2d = lag.lagfit(x, np.array([yw, yw]).T, 3, w=w)
         assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = lag.lagfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
         # test scaling with complex values x points whose square
         # is zero when summed.
         x = [1, 1j, -1, -1j]
         assert_almost_equal(lag.lagfit(x, x, 1), [1, -1])
+        assert_almost_equal(lag.lagfit(x, x, [0, 1]), [1, -1])
 
 
 class TestCompanion(TestCase):
diff --git a/numpy/polynomial/tests/test_legendre.py b/numpy/polynomial/tests/test_legendre.py
index 8ac1feb58..9c259d14c 100644
--- a/numpy/polynomial/tests/test_legendre.py
+++ b/numpy/polynomial/tests/test_legendre.py
@@ -388,6 +388,9 @@ class TestFitting(TestCase):
         def f(x):
             return x*(x - 1)*(x - 2)
 
+        def f2(x):
+            return x**4 + x**2 + 1
+
         # Test exceptions
         assert_raises(ValueError, leg.legfit, [1], [1], -1)
         assert_raises(TypeError, leg.legfit, [[1]], [1], 0)
@@ -397,6 +400,9 @@ class TestFitting(TestCase):
         assert_raises(TypeError, leg.legfit, [1], [1, 2], 0)
         assert_raises(TypeError, leg.legfit, [1], [1], 0, w=[[1]])
         assert_raises(TypeError, leg.legfit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, leg.legfit, [1], [1], [-1,])
+        assert_raises(ValueError, leg.legfit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, leg.legfit, [1], [1], [])
 
         # Test fit
         x = np.linspace(0, 2)
@@ -405,13 +411,25 @@ class TestFitting(TestCase):
         coef3 = leg.legfit(x, y, 3)
         assert_equal(len(coef3), 4)
         assert_almost_equal(leg.legval(x, coef3), y)
+        coef3 = leg.legfit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(leg.legval(x, coef3), y)
         #
         coef4 = leg.legfit(x, y, 4)
         assert_equal(len(coef4), 5)
         assert_almost_equal(leg.legval(x, coef4), y)
+        coef4 = leg.legfit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(leg.legval(x, coef4), y)
+        # check things still work if deg is not in strict increasing
+        coef4 = leg.legfit(x, y, [2, 3, 4, 1, 0])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(leg.legval(x, coef4), y)
         #
         coef2d = leg.legfit(x, np.array([y, y]).T, 3)
         assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = leg.legfit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
         # test weighting
         w = np.zeros_like(x)
         yw = y.copy()
@@ -419,13 +437,26 @@ class TestFitting(TestCase):
         y[0::2] = 0
         wcoef3 = leg.legfit(x, yw, 3, w=w)
         assert_almost_equal(wcoef3, coef3)
+        wcoef3 = leg.legfit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
         #
         wcoef2d = leg.legfit(x, np.array([yw, yw]).T, 3, w=w)
         assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = leg.legfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
         # test scaling with complex values x points whose square
         # is zero when summed.
         x = [1, 1j, -1, -1j]
         assert_almost_equal(leg.legfit(x, x, 1), [0, 1])
+        assert_almost_equal(leg.legfit(x, x, [0, 1]), [0, 1])
+        # test fitting only even Legendre polynomials
+        x = np.linspace(-1, 1)
+        y = f2(x)
+        coef1 = leg.legfit(x, y, 4)
+        assert_almost_equal(leg.legval(x, coef1), y)
+        coef2 = leg.legfit(x, y, [0, 2, 4])
+        assert_almost_equal(leg.legval(x, coef2), y)
+        assert_almost_equal(coef1, coef2)
 
 
 class TestCompanion(TestCase):
diff --git a/numpy/polynomial/tests/test_polynomial.py b/numpy/polynomial/tests/test_polynomial.py
index c806a8497..00a52ebce 100644
--- a/numpy/polynomial/tests/test_polynomial.py
+++ b/numpy/polynomial/tests/test_polynomial.py
@@ -419,6 +419,9 @@ class TestMisc(TestCase):
         def f(x):
             return x*(x - 1)*(x - 2)
 
+        def f2(x):
+            return x**4 + x**2 + 1
+
         # Test exceptions
         assert_raises(ValueError, poly.polyfit, [1], [1], -1)
         assert_raises(TypeError, poly.polyfit, [[1]], [1], 0)
@@ -428,6 +431,9 @@ class TestMisc(TestCase):
         assert_raises(TypeError, poly.polyfit, [1], [1, 2], 0)
         assert_raises(TypeError, poly.polyfit, [1], [1], 0, w=[[1]])
         assert_raises(TypeError, poly.polyfit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, poly.polyfit, [1], [1], [-1,])
+        assert_raises(ValueError, poly.polyfit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, poly.polyfit, [1], [1], [])
 
         # Test fit
         x = np.linspace(0, 2)
@@ -436,13 +442,21 @@ class TestMisc(TestCase):
         coef3 = poly.polyfit(x, y, 3)
         assert_equal(len(coef3), 4)
         assert_almost_equal(poly.polyval(x, coef3), y)
+        coef3 = poly.polyfit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(poly.polyval(x, coef3), y)
         #
         coef4 = poly.polyfit(x, y, 4)
         assert_equal(len(coef4), 5)
         assert_almost_equal(poly.polyval(x, coef4), y)
+        coef4 = poly.polyfit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(poly.polyval(x, coef4), y)
         #
         coef2d = poly.polyfit(x, np.array([y, y]).T, 3)
         assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = poly.polyfit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
         # test weighting
         w = np.zeros_like(x)
         yw = y.copy()
@@ -450,13 +464,26 @@ class TestMisc(TestCase):
         yw[0::2] = 0
         wcoef3 = poly.polyfit(x, yw, 3, w=w)
         assert_almost_equal(wcoef3, coef3)
+        wcoef3 = poly.polyfit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
         #
         wcoef2d = poly.polyfit(x, np.array([yw, yw]).T, 3, w=w)
         assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = poly.polyfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
         # test scaling with complex values x points whose square
         # is zero when summed.
         x = [1, 1j, -1, -1j]
         assert_almost_equal(poly.polyfit(x, x, 1), [0, 1])
+        assert_almost_equal(poly.polyfit(x, x, [0, 1]), [0, 1])
+        # test fitting only even Polyendre polynomials
+        x = np.linspace(-1, 1)
+        y = f2(x)
+        coef1 = poly.polyfit(x, y, 4)
+        assert_almost_equal(poly.polyval(x, coef1), y)
+        coef2 = poly.polyfit(x, y, [0, 2, 4])
+        assert_almost_equal(poly.polyval(x, coef2), y)
+        assert_almost_equal(coef1, coef2)
 
     def test_polytrim(self):
         coef = [2, -1, 1, 0]