```#!/usr/bin/env python
"""Unit tests for the svd-supporting functionality."""

from cogent.util.unit_test import TestCase, main
from cogent.maths.svd import ratio_two_best, ratio_best_to_sum, \
euclidean_distance, euclidean_norm, _dists_from_mean_slow, \
dists_from_v, weiss, three_item_combos, two_item_combos
from numpy import array, sqrt

__author__ = "Rob Knight"
__copyright__ = "Copyright 2007-2012, The Cogent Project"
__contributors__ = ["Rob Knight", "Daniel McDonald"]
__version__ = "1.5.3-dev"
__maintainer__ = "Rob Knight"
__status__ = "Production"

class functionTests(TestCase):
"""Tests of top-level functions."""

def test_ratio_two_best(self):
"""ratio_two_best should return ratio of two biggest items in list"""
v = array([3, 2, 5, 2, 4, 10, 3])
self.assertEqual(ratio_two_best(v), 2)
#should return 1 if items the same
v = array([2,2,2,2,2])
self.assertEqual(ratio_two_best(v), 1)
#check that it works on floating-point
v = array([3,2,1])
self.assertEqual(ratio_two_best(v), 1.5)

def test_ratio_best_to_sum(self):
"""ratio_best_to_sum should return ratio of biggest item to sum"""
v = [3, 2, 5, 2, 4, 10, 3]
self.assertFloatEqual(ratio_best_to_sum(v), 10/29.0)
v = [2,2,2,2,2]
self.assertEqual(ratio_best_to_sum(v), 2/10.0)
#check that it works on floating-point
v = [3,2,1]
self.assertEqual(ratio_best_to_sum(v), 0.5)

def test_euclidean_distance(self):
"""euclidean_distance should return distance between two points"""
first = array([2, 3, 4])
second = array([4, 8, 10])
self.assertEqual(euclidean_distance(first, first), 0)
self.assertEqual(euclidean_distance(second, second), 0)
self.assertFloatEqual(euclidean_distance(first, second), sqrt(65))
self.assertFloatEqual(euclidean_distance(second, first), sqrt(65))

def test_euclidean_norm(self):
"""euclidean_norm should match hand-calculated results"""
first = array([3,4])
self.assertEqual(euclidean_norm(first), 5)

def test_dists_from_mean_slow(self):
"""_dists_from_mean_slow should return distance of each item from mean"""
m = [[1,2,3,4],[2,3,4,5],[0,1,2,3]]
self.assertEqual(_dists_from_mean_slow(m), array([0.0,2.0,2.0]))

def test_dists_from_v(self):
"""dists_from_v should return distance of each item from v, or mean"""
m = [[1,2,3,4],[2,3,4,5],[0,1,2,3]]
#should calculate distances from mean by default
self.assertEqual(dists_from_v(m), array([0.0,2.0,2.0]))
#should caculate distances from vector if supplied
v = array([2,2,2,3])
self.assertEqual(dists_from_v(m, v), sqrt(array([3,9,5])))

def test_weiss(self):
"""weiss should perform weiss calculation correctly"""
e = array([12.0, 5.0, 0.1, 1e-3, 1e-15])
self.assertFloatEqual(weiss(e), 4.453018506827001)

def test_three_item_combos(self):
"""three_item_combos should return items in correct order"""
items = list(three_item_combos('abcde'))
self.assertEqual(items, map(tuple, \

def test_two_item_combos(self):
"""two_item_combos should return items in correct order"""
items = list(two_item_combos('abcd'))

def test_pca_qs(self):
"""pca_qs not tested b/c it just wraps eigenvalues(corrcoef(qs))"""
pass

def test_pca_cov_qs(self):
"""pca_cov_qs not tested b/c it just wraps eigenvalues(cov(qs))"""
pass

def test_svd_qs(self):
"""svd_qs not tested b/c it just wraps singular_value_decompositon(qs)"""
pass

if __name__ == '__main__':
main()

```