@@ -55,6 +55,33 @@ def test_mf_windowed_target_eq_one(self):
         y = spy.matched_filter(X, X[ij], window=(3, 7), cov=self.background.cov)
         np.allclose(1, y[ij])
 
+    def test_mf_windowed_target_eq_one_no_cov(self):
+        '''Windowed Matched Filter without a supplied `cov` (background
+        covariance recomputed for every window) should also score the
+        target pixel as one. A bigger window is needed here than in
+        `test_mf_windowed_target_eq_one` since, without a precomputed
+        `cov`, the outer window must contain at least as many pixels as
+        there are bands (220) to estimate a full-rank covariance.'''
+        X = self.data[:25, :25, :]
+        ij = (12, 12)
+        y = spy.matched_filter(X, X[ij], window=(3, 21))
+        assert np.allclose(1, y[ij])
+
+    def test_mf_whiten(self):
+        '''`whiten` should match its documented closed-form definition.'''
+        X = self.data[:5, :5, :].reshape(-1, self.data.shape[-1])
+        whitened = self.mf.whiten(X)
+        expected = (np.sqrt(self.mf.coef) * self.background.sqrt_inv_cov).dot(
+            (X - self.background.mean).T).T
+        assert np.allclose(whitened, expected)
+
+    def test_matched_filter_mutually_exclusive_raises(self):
+        from spectral.algorithms.detectors import matched_filter
+        (i, j) = self.target_ij
+        with pytest.raises(ValueError):
+            matched_filter(self.data, self.data[i, j],
+                           background=self.background, window=(3, 7))
+
 
 class TestRX:
     @pytest.fixture(autouse=True)
@@ -67,6 +94,49 @@ def test_rx_bg_eq_zero(self):
         stats = spy.calc_stats(self.data)
         np.testing.assert_approx_equal(rx(stats.mean, background=stats), 0)
 
+    def test_rx_call_without_background_computes_stats(self):
+        from spectral.algorithms.detectors import RX
+        detector = RX()
+        assert detector.background is None
+        scores = detector(self.data[:5, :5, :])
+        assert detector.background is not None
+        assert scores.shape == (5, 5)
+
+    def test_rx_call_rejects_non_ndarray(self):
+        from spectral.algorithms.detectors import RX
+        with pytest.raises(TypeError):
+            RX()([1, 2, 3])
+
+    def test_rx_mutually_exclusive_raises(self):
+        from spectral.algorithms.detectors import rx
+        with pytest.raises(ValueError):
+            rx(self.data, background=self.background, window=(3, 7))
+
+    def test_rx_windowed_flags_outlier(self):
+        '''A pixel that's a clear spectral outlier relative to its
+        surrounding window should score much higher than typical
+        (non-outlier) pixels.'''
+        from spectral.algorithms.detectors import rx
+        img = np.random.RandomState(0).normal(
+            size=(20, 20, 5)).astype(float)
+        outlier_ij = (10, 10)
+        img[outlier_ij] += 20.0
+        scores = rx(img, window=(3, 9))
+        assert scores[outlier_ij] > 10 * np.median(scores)
+
+    def test_rx_windowed_with_cov_flags_outlier(self):
+        '''Same as `test_rx_windowed_flags_outlier`, but supplying a
+        precomputed `cov` (only the background mean is recomputed per
+        window).'''
+        from spectral.algorithms.detectors import rx
+        img = np.random.RandomState(0).normal(
+            size=(20, 20, 5)).astype(float)
+        outlier_ij = (10, 10)
+        img[outlier_ij] += 20.0
+        cov = spy.calc_stats(img).cov
+        scores = rx(img, window=(3, 9), cov=cov)
+        assert scores[outlier_ij] > 10 * np.median(scores)
+
 
 class TestACE:
     @pytest.fixture(autouse=True)
@@ -157,3 +227,76 @@ def test_ace_windowed_target_eq_one(self):
         ij = (10, 10)
         y = spy.ace(self.X, self.X[ij], window=(3, 7), cov=self.bg.cov)
         assert (np.allclose(1, y[ij]))
+
+    def test_ace_windowed_target_eq_one_no_cov(self):
+        '''Same as `test_ace_windowed_target_eq_one`, but without a
+        precomputed `cov` (background mean and covariance are both
+        recomputed for every window). A bigger outer window is needed
+        here since, without a precomputed `cov`, it must contain at least
+        as many pixels as there are bands (220) to estimate a full-rank
+        covariance.'''
+        ij = (10, 10)
+        y = spy.ace(self.X, self.X[ij], window=(3, 19))
+        assert (np.allclose(1, y[ij]))
+
+    def test_ace_windowed_multi_targets_eq_one(self):
+        '''Windowed ACE score of each target, for a list of multiple
+        targets, should be one at that target's own pixel.'''
+        ij1 = (5, 5)
+        ij2 = (12, 14)
+        y = spy.ace(self.X, [self.X[ij1], self.X[ij2]], window=(3, 19))
+        assert y.shape == self.X.shape[:2] + (2,)
+        assert np.allclose(1, y[ij1][0])
+        assert np.allclose(1, y[ij2][1])
+
+    def test_ace_windowed_multi_targets_eq_one_with_cov(self):
+        '''Same as `test_ace_windowed_multi_targets_eq_one`, but with a
+        precomputed `cov`.'''
+        ij1 = (5, 5)
+        ij2 = (12, 14)
+        y = spy.ace(self.X, [self.X[ij1], self.X[ij2]], window=(3, 7),
+                    cov=self.bg.cov)
+        assert y.shape == self.X.shape[:2] + (2,)
+        assert np.allclose(1, y[ij1][0])
+        assert np.allclose(1, y[ij2][1])
+
+    def test_ace_set_target_none(self):
+        from spectral.algorithms.detectors import ACE
+        ij = (10, 10)
+        detector = ACE(self.X[ij], background=self.bg)
+        assert detector._P is not None
+        detector.set_target(None)
+        assert detector._target is None
+        assert detector._P is None
+
+    def test_ace_call_rejects_non_ndarray(self):
+        from spectral.algorithms.detectors import ACE
+        ij = (10, 10)
+        detector = ACE(self.X[ij], background=self.bg)
+        with pytest.raises(TypeError):
+            detector([1, 2, 3])
+
+    def test_ace_auto_background(self):
+        '''Constructing an ACE detector without `background` and calling
+        it directly should compute background stats from the given data.'''
+        from spectral.algorithms.detectors import ACE
+        ij = (10, 10)
+        detector = ACE(self.X[ij])
+        assert detector._background is None
+        scores = detector(self.X)
+        assert detector._background is not None
+        assert np.allclose(1, scores[ij])
+
+    def test_ace_function_auto_background_multi_target(self):
+        '''`spy.ace` with a list of targets and no `background`/`window`
+        should compute background stats once from the given data.'''
+        ij1 = (5, 5)
+        ij2 = (12, 14)
+        y = spy.ace(self.X, [self.X[ij1], self.X[ij2]])
+        assert np.allclose(1, y[ij1][0])
+        assert np.allclose(1, y[ij2][1])
+
+    def test_ace_function_mutually_exclusive_raises(self):
+        ij = (10, 10)
+        with pytest.raises(ValueError):
+            spy.ace(self.X, self.X[ij], background=self.bg, window=(3, 7))
@@ -0,0 +1,237 @@
+'''Tests of the multilayer perceptron classifier.
+
+Training tests seed `numpy.random` before constructing each `Perceptron`
+(whose layer weights are otherwise randomly initialized) so that training
+behavior is reproducible; the AND gate is used as training data since it's
+linearly separable and converges quickly and reliably.
+
+The demo functions at the bottom of `perceptron.py` (`test_xor`, `test_and`,
+etc., and the `if __name__ == '__main__'` block) are standalone scripts
+that just forward to `Perceptron.train`, already covered thoroughly below;
+they're intentionally not exercised here.
+
+To run the unit tests, type the following from the system command line:
+
+    # pytest spectral/tests/test_perceptron.py
+'''
+
+import io
+
+import numpy as np
+from numpy.testing import assert_allclose
+import pytest
+
+from spectral.algorithms.perceptron import (Perceptron, PerceptronLayer,
+                                            and_data)
+
+AND_XY = list(zip(*and_data))
+
+
+class TestPerceptronLayer:
+
+    def test_shape(self):
+        layer = PerceptronLayer((3, 2))
+        assert layer.shape == (2, 4)
+        assert layer.weights.shape == (2, 4)
+
+    def test_explicit_weights(self):
+        weights = np.arange(8, dtype=float).reshape(2, 4)
+        layer = PerceptronLayer((3, 2), weights=weights)
+        assert_allclose(layer.weights, weights)
+
+    def test_explicit_weights_wrong_shape_raises(self):
+        weights = np.zeros((2, 3))
+        with pytest.raises(Exception):
+            PerceptronLayer((3, 2), weights=weights)
+
+    def test_randomize_weights_unit_length(self):
+        layer = PerceptronLayer((5, 4))
+        norms = np.sqrt((layer.weights[:, 1:] ** 2).sum(axis=1))
+        assert_allclose(norms, np.ones(4))
+
+    def test_input_and_activation(self):
+        layer = PerceptronLayer((2, 1))
+        layer.weights = np.array([[0.0, 1.0, -1.0]])
+        y = layer.input([2.0, 5.0])
+        expected = 1. / (1. + np.exp(3.0))
+        assert_allclose(y, [expected])
+
+    def test_input_clip(self):
+        layer = PerceptronLayer((2, 1))
+        layer.weights = np.array([[100.0, 1.0, -1.0]])  # saturates near 1
+        y = layer.input([100.0, 0.0], clip=0.1)
+        assert_allclose(y, [0.9])
+
+    def test_dy_da(self):
+        layer = PerceptronLayer((2, 1))
+        layer.weights = np.array([[0.0, 1.0, -1.0]])
+        layer.input([2.0, 5.0])
+        expected = layer.k * layer.y * (1.0 - layer.y)
+        assert_allclose(layer.dy_da(), expected)
+
+
+class TestPerceptronConstruction:
+
+    def test_invalid_layers_type_raises(self):
+        with pytest.raises(Exception):
+            Perceptron('not a list')
+
+    def test_too_few_layers_raises(self):
+        with pytest.raises(Exception):
+            Perceptron([3])
+
+    def test_layer_shapes(self):
+        p = Perceptron([3, 4, 2])
+        assert p.layers[0].shape == (4, 4)
+        assert p.layers[1].shape == (2, 5)
+
+
+class TestPerceptronInputClassify:
+
+    @pytest.fixture
+    def scaled_perceptron(self):
+        '''A single-layer Perceptron with known weights and scaling set
+        directly (bypassing `train`, which is what normally establishes
+        `_scale`/`_offset`) so `input`/`classify` can be checked in
+        isolation against a hand-computed expected value.'''
+        p = Perceptron([2, 1])
+        p._scale = np.array([1.0, 1.0])
+        p._offset = np.array([0.0, 0.0])
+        p.layers[0].weights = np.array([[0.0, 1.0, -1.0]])
+        return p
+
+    def test_input(self, scaled_perceptron):
+        result = scaled_perceptron.input([2.0, 5.0])
+        expected = 1. / (1. + np.exp(3.0))
+        assert_allclose(result, [expected])
+
+    def test_classify(self, scaled_perceptron):
+        # Large positive z -> sigmoid saturates near 1 -> rounds to 1.
+        assert scaled_perceptron.classify([10.0, 0.0]) == [1]
+        # Large negative z -> sigmoid saturates near 0 -> rounds to 0.
+        assert scaled_perceptron.classify([0.0, 10.0]) == [0]
+
+
+class TestSetScaling:
+
+    def test_handles_constant_feature(self):
+        '''A feature that's constant across all training samples has zero
+        range; `_set_scaling` should avoid a divide-by-zero for it rather
+        than producing an inf/nan scale factor.'''
+        np.random.seed(0)
+        p = Perceptron([2, 1])
+        X = [[1.0, 0.0], [1.0, 1.0], [1.0, 0.0], [1.0, 1.0]]
+        p._set_scaling(X)
+        assert np.all(np.isfinite(p._scale))
+
+
+class TestPerceptronTrain:
+
+    def test_converges_on_and_gate(self):
+        np.random.seed(0)
+        p = Perceptron([2, 1])
+        out = io.StringIO()
+        trained = p.train(*AND_XY, max_iterations=2000, stdout=out)
+        assert trained is True
+        assert p.accuracy == 100.0
+
+    @pytest.mark.parametrize('batch', [0, 1, 3])
+    def test_batch_options_converge(self, batch):
+        np.random.seed(0)
+        p = Perceptron([2, 1])
+        out = io.StringIO()
+        trained = p.train(*AND_XY, max_iterations=3000, batch=batch,
+                          stdout=out)
+        assert trained is True
+
+    def test_momentum_converges(self):
+        np.random.seed(0)
+        p = Perceptron([2, 1])
+        out = io.StringIO()
+        trained = p.train(*AND_XY, max_iterations=3000, momentum=0.5,
+                          stdout=out)
+        assert trained is True
+
+    def test_accuracy_over_100_runs_full_iterations(self):
+        '''Setting `accuracy` above 100 (the maximum achievable) forces
+        `train` to run for the full `max_iterations` rather than stopping
+        early once 100% accuracy is reached.'''
+        np.random.seed(0)
+        p = Perceptron([2, 1])
+        out = io.StringIO()
+        trained = p.train(*AND_XY, max_iterations=5, accuracy=200.0,
+                          stdout=out)
+        assert trained is False
+
+    def test_stdout_none_is_suppressed(self):
+        np.random.seed(0)
+        p = Perceptron([2, 1])
+        p.train(*AND_XY, max_iterations=5, stdout=None)
+
+    def test_on_iteration_callback_stops_training(self):
+        np.random.seed(0)
+        p = Perceptron([2, 1])
+        calls = []
+
+        def on_iteration(perceptron):
+            calls.append(perceptron.accuracy)
+            return True
+
+        out = io.StringIO()
+        trained = p.train(*AND_XY, max_iterations=100,
+                          on_iteration=on_iteration, stdout=out)
+        assert trained is True
+        assert len(calls) == 1
+
+    def test_keyboard_interrupt_during_training(self):
+        np.random.seed(0)
+        p = Perceptron([2, 1])
+
+        def raise_interrupt(perceptron):
+            raise KeyboardInterrupt
+
+        out = io.StringIO()
+        trained = p.train(*AND_XY, max_iterations=100,
+                          on_iteration=raise_interrupt, stdout=out)
+        assert trained is False
+        assert 'KeyboardInterrupt' in out.getvalue()
+
+
+class RaisingArray(np.ndarray):
+    '''An ndarray whose in-place addition always raises KeyboardInterrupt,
+    used to simulate a CTRL-C occurring mid weight-update.'''
+    def __iadd__(self, other):
+        raise KeyboardInterrupt
+
+
+class TestAdjustWeightsInterrupt:
+    '''Tests `Perceptron._adjust_weights`'s own KeyboardInterrupt handling
+    directly, isolated from the full `train` loop.'''
+
+    def _make_perceptron_with_raising_weights(self):
+        np.random.seed(0)
+        p = Perceptron([2, 1])
+        layer = p.layers[0]
+        layer.dW = np.ones_like(layer.weights) * 0.1
+        original_weights = np.array(layer.weights)
+        layer.weights = layer.weights.view(RaisingArray)
+        return (p, layer, original_weights)
+
+    def test_restores_previous_weights_when_caching(self):
+        (p, layer, original_weights) = \
+            self._make_perceptron_with_raising_weights()
+        out = io.StringIO()
+        with pytest.raises(KeyboardInterrupt):
+            p._adjust_weights(0.3, 0.0, 1, out)
+        assert_allclose(np.asarray(layer.weights), original_weights)
+        assert_allclose(layer.dW, 0)
+        assert 'Restoring previous weights' in out.getvalue()
+
+    def test_leaves_weights_when_caching_disabled(self):
+        (p, layer, original_weights) = \
+            self._make_perceptron_with_raising_weights()
+        p.cache_weights = False
+        out = io.StringIO()
+        with pytest.raises(KeyboardInterrupt):
+            p._adjust_weights(0.3, 0.0, 1, out)
+        assert 'cacheing was disabled' in out.getvalue()