def test_ransom_seed(self): """Test setting random seeds. """ np.random.seed(12345) value = helpers.rand(2, 2) self.assertFalse(np.allclose(value, helpers.rand(2, 2))) np.random.seed(12345) self.assertTrue(np.allclose(value, helpers.rand(2, 2))) np.random.seed(12346) self.assertFalse(np.allclose(value, helpers.rand(2, 2)))
def test_two(self): """ Test for 2 by 2 matrix. """ m = helpers.eye(2) v = helpers.rand(2, 2) self.assertTrue(np.array_equal(m.dot(v), v)) self.assertTrue(np.array_equal(v.dot(m), v))
def test_one(self): """ Test for 1 by 1 matrix. """ m = helpers.eye(1) v = helpers.rand(1) self.assertTrue(np.array_equal(m.dot(v), v)) self.assertTrue(np.array_equal(v.dot(m), v))
def _make_ygen(self): self._make_u() num_double_at_upper = self.info[ 'md_upp_deg'] + self.info['md_upp_nonactive'] num_not_floating = self.info['md'] - self.info['md_float'] double_at_upper = npvec(self.u[:num_double_at_upper]) double_at_lower = zeros( self.info['md_low_deg'] + self.info['md_low_nonactive']) double_floating = npvec( [randcst() * x for x in self.u[num_not_floating:]]) single_at_lower = zeros( self.info['ms_deg'] + self.info['ms_nonactive']) single_floating = rand(self.info['ms_active']) # ygen = conmat([npvec(u[:m_upp_deg+upp_nonactive]), # double_at_upper # zeros(m_low_deg+low_nonactive), # double_at_lower # v2, # double_floating # zeros(m_inf_deg+inf_nonactive), # single_at_lower # rand(m_inf-m_inf_deg-inf_nonactive)]) # single_floating self.info['ygen'] = conmat([ double_at_upper, # y=u cases double_at_lower, # y=0 cases double_floating, # 0<y<u cases single_at_lower, # y=0 cases single_floating]) # y>0 cases for yi in self.info['ygen']: assert yi >= 0 for i in range(self.info['md']): assert self.info['ygen'][i] <= self.u[i]
def test_non_diagonal_matrix(self): """ Test for multiple of non diagonal matrix and raise errors. """ for size in range(2, 101): PU = PV = np.identity(size) PD = helpers.rand(size) cond = 73 self.assertRaises(ValueError, helpers.adjust_cond, PU, PD, PV, cond)
def evaluate(self, size): """ Evaluate with a give size matrix. Args: size: Matrix size. """ m = helpers.rand(size, size) PU, PD, PV = helpers.schur(m) self.assertTrue(np.allclose(np.dot(PU, np.dot(PD, PV)), m))
def evaluate(self, size): """ Evaluate with a give size matrix. Args: size: Matrix size. """ ms = [helpers.rand(size, size) for _ in range(3)] ans = functools.reduce(lambda u, v: u.dot(v), ms) self.assertTrue(np.allclose(helpers.reconstruct(*ms), ans))
def _make_a_ulambda(self): xgen = self.info['xgen'] ygen = self.info['ygen'] # FIRST LEVEL CTRS A[x;y] + a <= 0 # Generate the first level multipliers ulambda associated with A*[x;y]+a<=0. # Generate a so the constraints Ax+a <= 0 are loose or tight where # appropriate. Axy = self.A * conmat([xgen, ygen]) self.a = -Axy - conmat([ zeros(self.info['l_deg']), # A + a = 0 rand(self.info['l_nonactive']), # A + a = 0 zeros(self.info['l_active'])]) # A + a <=0 self.info['ulambda'] = conmat([ zeros(self.info['l_deg']), zeros(self.info['l_nonactive']), rand(self.info['l_active'])])
def evaluate(self, shape, **kwargs): """ Evaluate rand. Args: shape: Shape of result matrix of randint. kwargs: To be passed to randint. """ m = helpers.rand(**kwargs) self.assertEqual(m.shape, shape) self.assertGreaterEqual(m.min(), 0) self.assertLessEqual(m.max(), 1)
def test(self): """ Test with a 100 by 100 matrix. """ size = 100 m = helpers.rand(size, size) min_diagonal = m.diagonal().min() res = helpers.tweak_diag(m) for i in range(size): self.assertGreaterEqual(res[i, i], m[i, i] - min_diagonal) self.assertLessEqual(res[i, i], m[i, i] - min_diagonal + 1)
def evaluate(self, size): """ Evaluate with a give size matrix. Args: size: Matrix size. """ m = helpers.rand(size, size) PU, PD, PV = helpers.svd(m) self.assertTrue(np.allclose(np.dot(PU, np.dot(PD, PV)), m)) for i in range(size): for j in range(size): if i != j: self.assertEqual(PD[i, j], 0)
def test(self): """ Test with a simple input. """ m = helpers.rand(100, 100) ans = m.diagonal().max() self.assertEqual(helpers.maxdiag(m), ans)
def setUp(self): """ Prepare tests. """ u = helpers.rand(3, 3) v = helpers.rand(3, 3) self.tup = (u, v)
def _make_F_pi_sigma_index(self): N = self.N M = self.M u = self.u xgen = self.info['xgen'] ygen = self.info['ygen'] m = self.param['m'] # Design q so that Nx + My + E^Tlambda + q = 0 at the solution (xgen, # ygen) q = -N * xgen - M * ygen q += conmat([ # double bounded, degenerate at upper zeros(self.info['md_upp_deg']), # double bounded, nonactive at upper -rand(self.info['md_upp_nonactive']), # double bounded, degenerate at lower zeros(self.info['md_low_deg']), # double bounded, nonactive at lower rand(self.info['md_low_nonactive']), zeros(self.info['md_float']), # double bounded, floating # single bounded, degenerate at lower zeros(self.info['ms_deg']), # single bounded, nonactive at lower rand(self.info['ms_nonactive']), zeros(self.info['ms_active'])]) # single bounded, floating ######################################### ## For later convenience ## ######################################### F = N * xgen + M * ygen + q mix_deg = self.param['mix_deg'] tol_deg = self.param['tol_deg'] # Calculate three index sets alpha, beta and gamma at (xgen, ygen). # alpha denotes the index set of i at which F(i) is active, but y(i) not. # beta_upp and beta_low denote the index sets of i at which F(i) is # active, and y(i) is active at the upper and the lower end point of # the finite interval [0, u] respectively. # beta_inf denotes the index set of i at which both F(i) and y(i) are # active for the infinite interval [0, inf). # gamma_upp and gamma_low denote the index sets of i at which F(i) is # not active, but y(i) is active at the upper and the lower point of # the finite interval [0, u] respectively. # gamma_inf denotes the index set of i at which F(i) is not active, but y(i) # is active for the infinite interval [0, inf). index = [] md = self.info['md'] for i in range(md): assert ygen[i] >= -tol_deg and ygen[i] < u[i] + tol_deg, \ "{0} not in [0, {1}]".format(ygen[i], u[i]) if abs(F[i]) <= tol_deg and ygen[i] > tol_deg and ygen[i] + tol_deg < u[i]: index.append(1) # For the index set alpha. elif abs(F[i]) <= tol_deg and abs(ygen[i] - u[i]) <= tol_deg: index.append(2) # For the index set beta_upp. elif abs(F[i]) <= tol_deg and abs(ygen[i]) <= tol_deg: index.append(3) # For the index set beta_low. elif F[i] < -tol_deg and abs(ygen[i] - u[i]) <= tol_deg: index.append(-1) # For the index set gamma_upp. elif F[i] > tol_deg and abs(ygen[i]) <= tol_deg: index.append(-1) # For the index set gamma_low. else: raise Exception(("didn't know what to do with this case: " "ygen={0}, u[i] = {1}, F[i]={2}").format( ygen[i], u[i], F[i])) for i in range(md, m): if ygen[i] > F[i] + tol_deg: index.append(1) # For the index set alpha. elif abs(ygen[i] - F[i]) <= tol_deg: index.append(4) # For the index set beta_inf. else: index.append(-1) # For the index set gamma_inf. # Generate the first level multipliers pi sigma # associated with other constraints other than the first level constraints # A*[x;y]+a<=0 in the relaxed nonlinear program. In particular, # pi is associated with F(x, y)=N*x+M*y+q, and # sigma with y. mix_upp_deg = max( mix_deg - self.info['md_low_deg'] - self.info['ms_deg'], choose_num(self.info['md_upp_deg'])) mix_upp_deg = min(mix_upp_deg, mix_deg) mix_low_deg = max( mix_deg - mix_upp_deg - self.info['ms_deg'], choose_num(self.info['md_low_deg'])) mix_low_deg = min(mix_low_deg, mix_deg - mix_upp_deg) mix_inf_deg = mix_deg - mix_upp_deg - mix_low_deg mix_inf_deg = min(mix_inf_deg, mix_deg - mix_upp_deg - mix_inf_deg) assert mix_deg >= 0 assert mix_upp_deg >= 0 assert mix_low_deg >= 0 assert mix_inf_deg >= 0 # assert self.param['second_deg'] == self.info['ms_deg'] + # self.info['md_low_deg'] + self.info['md_upp_deg'] + mix_deg k_mix_inf = 0 k_mix_upp = 0 k_mix_low = 0 pi = zeros(m, 1) sigma = zeros(m, 1) for i in range(m): if index[i] == 1: pi[i] = randcst() - randcst() sigma[i] = 0 elif index[i] == 2: if k_mix_upp < mix_upp_deg: pi[i] = 0 # The first mix_upp_deg constraints associated with F(i)<=0 # in the set beta_upp are degenerate. sigma[i] = 0 # The first mix_upp_deg constraints associated with # y(i)<=u(i) in the set beta_upp are degenerate. k_mix_upp = k_mix_upp + 1 else: pi[i] = randcst() sigma[i] = randcst() elif index[i] == 3: if k_mix_low < mix_low_deg: pi[i] = 0 # The first mix_low_deg constraints associated with F(i)>=0 # in the set beta_low are degenerate. sigma[i] = 0 # The first mix_low_deg constraints associated with # y(i)>=0 in the set beta_low are degenerate. k_mix_low = k_mix_low + 1 else: pi[i] = -randcst() sigma[i] = -randcst() elif index[i] == 4: if k_mix_inf < mix_inf_deg: pi[i] = 0 # The first mix_inf_deg constraints associated with F(i)>=0 # in the set beta_inf are degenerate. sigma[i] = 0 # The first mix_inf_deg constraints associated with # y(i)>=0 in the set beta_inf are degenerate. k_mix_inf = k_mix_inf + 1 else: pi[i] = -randcst() sigma[i] = -randcst() else: pi[i] = 0 sigma[i] = randcst() - randcst() self.q = q self.info.update({ 'F': F, 'mix_upp_deg': mix_upp_deg, 'mix_low_deg': mix_low_deg, 'mix_inf_deg': mix_inf_deg, 'pi': pi, 'sigma': sigma})
def _make_u(self): self.u = 10. * rand(self.info['md'])
def _make_xgen(self): self.info['xgen'] = 10 * (rand(self.n) - rand(self.n))