def test_matrix_set(self):
m1 = Matrix(2, 2)
m1.setAll(99)
self.assertEqual(99, m1[0, 0])
self.assertEqual(99, m1[1, 1])
m2 = Matrix(2, 2, value=99)
self.assertEqual(m1, m2)
def test_copy_equal(self):
m1 = Matrix(2, 2)
m1[0, 0] = 0
m1[0, 1] = 1
m1[1, 0] = 2
m1[1, 1] = 3
m2 = m1.copy()
self.assertTrue(m1 == m2)
def update(rng, mask, module, ert, meas_data, obs_data, state_size):
S = meas_data.createS()
R = obs_data.createR()
dObs = obs_data.createDObs()
E = obs_data.createE(rng, meas_data.getActiveEnsSize())
D = obs_data.createD(E, S)
obs_data.scale(S, E=E, D=D, R=R, D_obs=dObs)
A = Matrix(state_size, meas_data.getActiveEnsSize())
A.randomInit(rng)
module.initUpdate(mask, S, R, dObs, E, D)
module.updateA(A, S, R, dObs, E, D)
def polyfit(n, x, y, s=None):
"""
@type n: int
@type x: Matrix or Sequence or DoubleVector
@type y: Matrix or Sequence or DoubleVector
@type s: Matrix or Sequence or DoubleVector or None
@return: tuple
"""
if _polyfit is None:
raise NotImplementedError(
"Sorry - your ert distribution has been built without lapack support"
)
if isinstance(x, Matrix):
xm = x
else:
xm = Matrix(len(x), 1)
for i in range(len(x)):
xm[i, 0] = x[i]
if isinstance(y, Matrix):
ym = y
else:
ym = Matrix(len(y), 1)
for i in range(len(y)):
ym[i, 0] = y[i]
if s:
if isinstance(s, Matrix):
sm = s
else:
sm = Matrix(len(s), 1)
for i in range(len(s)):
sm[i, 0] = s[i]
else:
sm = s
beta = Matrix(n, 1)
res = _polyfit(beta, xm, ym, sm)
if not res == LLSQResultEnum.LLSQ_SUCCESS:
raise Exception("Linear Least Squares Estimator failed?")
l = []
for i in range(n):
l.append(beta[i, 0])
return tuple(l)
def init_matrices(ens, mask, obs, rng):
state_size = 2
report_step = 5
meas_data = MeasData(mask)
meas_block = meas_data.addBlock("OBS", report_step, len(obs))
A = Matrix(state_size, mask.countEqual(True))
active_iens = 0
for iens, params in enumerate(ens):
if mask[iens]:
state = forward_model(params)
meas_block[0, iens] = measure(state)
A[0, active_iens] = params[0]
A[1, active_iens] = params[1]
active_iens += 1
S = meas_data.createS()
obs_data = ObsData()
obs_block = obs_data.addBlock("OBS", 1)
for iobs, obs_value in enumerate(obs):
obs_block[iobs] = obs_value
R = obs_data.createR()
dObs = obs_data.createDObs()
E = obs_data.createE(rng, meas_data.getActiveEnsSize())
D = obs_data.createD(E, S)
obs_data.scale(S, E=E, D=D, R=R, D_obs=dObs)
return (A, S, E, D, R, dObs)
def test_analysis_module(self):
rng = RandomNumberGenerator()
module = self.createAnalysisModule()
ens_size = 12
obs_size = 1
state_size = 2
true_params = [1.25, 0.75]
true_state = forward_model(true_params)
obs = [(measure(true_state), 0.75)]
A = Matrix(state_size, ens_size)
ens = []
for iens in range(ens_size):
param = [random.gauss(1.00, 1.00), random.gauss(1.00, 1.00)]
ens.append(param)
mask = BoolVector(default_value=True, initial_size=ens_size)
mask[2] = False
(A, S, E, D, R, dObs) = init_matrices(ens, mask, obs, rng)
module.initUpdate(mask, S, R, dObs, E, D, rng)
module.updateA(A, S, R, dObs, E, D, rng)
mask[10] = False
mask[5] = False
(A, S, E, D, R, dObs) = init_matrices(ens, mask, obs, rng)
self.assertEqual(S.dims(), (obs_size, mask.countEqual(True)))
self.assertEqual(E.dims(), (obs_size, mask.countEqual(True)))
self.assertEqual(D.dims(), (obs_size, mask.countEqual(True)))
module.initUpdate(mask, S, R, dObs, E, D, rng)
module.updateA(A, S, R, dObs, E, D, rng)
def test_transpose(self):
m = Matrix(3, 2)
m[0, 0] = 0
m[1, 0] = 2
m[2, 0] = 4
m[0, 1] = 1
m[1, 1] = 3
m[2, 1] = 5
mt = m.transpose()
self.assertEqual(m[0, 0], 0)
self.assertEqual(m[1, 0], 2)
self.assertEqual(m[2, 0], 4)
self.assertEqual(m[0, 1], 1)
self.assertEqual(m[1, 1], 3)
self.assertEqual(m[2, 1], 5)
self.assertEqual(mt.rows(), m.columns())
self.assertEqual(mt.columns(), m.rows())
self.assertEqual(mt[0, 0], 0)
self.assertEqual(mt[1, 0], 1)
self.assertEqual(mt[0, 1], 2)
self.assertEqual(mt[1, 1], 3)
self.assertEqual(mt[0, 2], 4)
self.assertEqual(mt[1, 2], 5)
m.transpose(inplace=True)
self.assertEqual(m, mt)
def construct_matrix(self, n, vals):
"""Constructs n*n matrix with vals as entries"""
self.assertEqual(n * n, len(vals))
m = Matrix(n, n)
idx = 0
for i in range(n):
for j in range(n):
m[(i, j)] = vals[idx]
idx += 1
return m
def test_matrix_equality(self):
m = Matrix(2, 2)
m[0, 0] = 2
m[1, 1] = 4
s = Matrix(2, 3)
s[0, 0] = 2
s[1, 1] = 4
self.assertNotEqual(m, s)
r = Matrix(2, 2)
r[0, 0] = 2
r[1, 1] = 3
self.assertNotEqual(m, r)
r[1, 1] = 4
self.assertEqual(m, r)
def calculatePrincipalComponent(self,
fs,
local_obsdata,
truncation_or_ncomp=3):
pc = Matrix(1, 1)
pc_obs = Matrix(1, 1)
singular_values = DoubleVector()
state_map = fs.getStateMap()
ens_mask = BoolVector(False, self.ert().getEnsembleSize())
state_map.selectMatching(ens_mask, RealizationStateEnum.STATE_HAS_DATA)
active_list = ens_mask.createActiveList()
if len(ens_mask) > 0:
meas_data = MeasData(ens_mask)
obs_data = ObsData()
self.ert().getObservations().getObservationAndMeasureData(
fs, local_obsdata, active_list, meas_data, obs_data)
meas_data.deactivateZeroStdSamples(obs_data)
active_size = len(obs_data)
if active_size > 0:
S = meas_data.createS()
D_obs = obs_data.createDObs()
truncation, ncomp = self.truncationOrNumberOfComponents(
truncation_or_ncomp)
obs_data.scale(S, D_obs=D_obs)
EnkfLinalg.calculatePrincipalComponents(
S, D_obs, truncation, ncomp, pc, pc_obs, singular_values)
if self.__prior_singular_values is None:
self.__prior_singular_values = singular_values
else:
for row in range(pc.rows()):
factor = singular_values[
row] / self.__prior_singular_values[row]
pc.scaleRow(row, factor)
pc_obs.scaleRow(row, factor)
return PcaPlotData(local_obsdata.getName(), pc, pc_obs,
singular_values)
return None
def test_str(self):
m = Matrix(2, 2)
s = "%s" % m
m[0, 0] = 0
m[0, 1] = 1
m[1, 0] = 2
m[1, 1] = 3
with TestAreaContext("matrix_fprint"):
with open("matrix.txt", "w") as f:
m.fprint(f)
with open("matrix.txt") as f:
l1 = [float(x) for x in f.readline().split()]
l2 = [float(x) for x in f.readline().split()]
self.assertEqual(l1[0], m[0, 0])
self.assertEqual(l1[1], m[0, 1])
self.assertEqual(l2[0], m[1, 0])
self.assertEqual(l2[1], m[1, 1])
def test_matrix(self):
m = Matrix(2, 3)
self.assertEqual(m.rows(), 2)
self.assertEqual(m.columns(), 3)
self.assertEqual(m[(0, 0)], 0)
m[(1, 1)] = 1.5
self.assertEqual(m[(1, 1)], 1.5)
m[1, 0] = 5
self.assertEqual(m[1, 0], 5)
with self.assertRaises(TypeError):
m[5] = 5
with self.assertRaises(IndexError):
m[2, 0] = 0
with self.assertRaises(IndexError):
m[0, 3] = 0
def test_sub_copy(self):
m1 = Matrix(3, 3)
rng = RandomNumberGenerator(RngAlgTypeEnum.MZRAN, RngInitModeEnum.INIT_DEFAULT)
m1.randomInit(rng)
with self.assertRaises(ValueError):
m2 = m1.subCopy(0, 0, 4, 2)
with self.assertRaises(ValueError):
m2 = m1.subCopy(0, 0, 2, 4)
with self.assertRaises(ValueError):
m2 = m1.subCopy(4, 0, 1, 1)
with self.assertRaises(ValueError):
m2 = m1.subCopy(0, 2, 1, 2)
m2 = m1.subCopy(0, 0, 2, 2)
for i in range(2):
for j in range(2):
self.assertEqual(m1[i, j], m2[i, j])
def test_num_PC(self):
S = Matrix(3, 3)
S[0, 0] = 1
S[1, 1] = 1
S[2, 2] = 1
with self.assertRaises(ValueError):
num_pc = Linalg.numPC(S, 0)
with self.assertRaises(ValueError):
num_pc = Linalg.numPC(S, 1.5)
num_pc = Linalg.numPC(S, 0.20)
self.assertEqual(num_pc, 1)
num_pc = Linalg.numPC(S, 0.50)
self.assertEqual(num_pc, 2)
num_pc = Linalg.numPC(S, 0.80)
self.assertEqual(num_pc, 3)
def test_matmul(self):
m1 = Matrix(3, 3)
m2 = Matrix(2, 2)
with self.assertRaises(ValueError):
Matrix.matmul(m1, m2)
m = Matrix(3, 2)
m[0, 0] = 0
m[1, 0] = 2
m[2, 0] = 4
m[0, 1] = 1
m[1, 1] = 3
m[2, 1] = 5
mt = m.transpose()
m2 = Matrix.matmul(m, mt)
self.assertEqual(m2[0, 0], 1)
self.assertEqual(m2[1, 1], 13)
self.assertEqual(m2[2, 2], 41)
def test_identity(self):
m1 = Matrix.identity(1)
self.assertEqual(m1.rows(), 1)
self.assertEqual(m1.columns(), 1)
self.assertEqual(m1[0, 0], 1)
with self.assertRaises(ValueError):
Matrix.identity(0)
with self.assertRaises(ValueError):
Matrix.identity(-3)
m = Matrix.identity(17)
self.assertEqual(m.rows(), 17)
self.assertEqual(m.columns(), 17)
for i in range(17):
for j in range(17):
elt = m[i, j]
if i == j:
self.assertEqual(elt, 1)
else:
self.assertEqual(elt, 0)
def test_matrix_copy_column(self):
m = Matrix(10, 2)
rng = RandomNumberGenerator(RngAlgTypeEnum.MZRAN,
RngInitModeEnum.INIT_DEFAULT)
m.randomInit(rng)
with self.assertRaises(ValueError):
m.copyColumn(0, 2)
with self.assertRaises(ValueError):
m.copyColumn(2, 0)
with self.assertRaises(ValueError):
m.copyColumn(-2, 0)
m.copyColumn(1, 0)
for i in range(m.rows()):
self.assertEqual(m[i, 0], m[i, 1])
def _n_identity_mcs(self, n=6, s=3):
"""return n copies of the identity matrix on s*s elts"""
return tuple([Matrix.identity(s) for i in range(n)])
def test_csv(self):
m = Matrix(2, 2)
m[0, 0] = 2
m[1, 1] = 4
with TestAreaContext("matrix_csv"):
m.dumpCSV("matrix.csv")
def initX(self, A, S, R, dObs, E, D, rng):
X = Matrix(A.columns(), A.columns())
self._initX(X, A, S, R, dObs, E, D, rng)
return X
def test_matrix_scale(self):
m = Matrix(2, 2, value=1)
m.scaleColumn(0, 2)
self.assertEqual(2, m[0, 0])
self.assertEqual(2, m[1, 0])
m.setAll(1)
m.scaleRow(1, 2)
self.assertEqual(2, m[1, 0])
self.assertEqual(2, m[1, 1])
with self.assertRaises(IndexError):
m.scaleColumn(10, 99)
with self.assertRaises(IndexError):
m.scaleRow(10, 99)
def test_matrix_random_init(self):
m = Matrix(10, 10)
rng = RandomNumberGenerator(RngAlgTypeEnum.MZRAN,
RngInitModeEnum.INIT_DEFAULT)
m.randomInit(rng)
