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
@type y: Matrix or Sequence
@type s: Matrix or Sequence 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 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)
module.updateA(A, S, R, dObs, E, D)
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)
module.updateA(A, S, R, dObs, E, D)
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_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 __sortFaultLines(self):
N = len(self.__fault_lines)
x = Matrix(N , 1)
y = Matrix(N , 1)
for index,line in enumerate(self.__fault_lines):
xc,yc = line.center()
x[index,0] = xc
y[index,0] = yc
# y = beta[0] + beta[1] * x
# = a + b * x
beta = stat.polyfit(2 , x , y)
a = beta[0]
b = beta[1]
perm_list = []
for index,line in enumerate(self.__fault_lines):
x0 , y0 = line.center()
d = x0 + b*(y0 - a)
perm_list.append((index , d))
perm_list.sort(key = lambda x: x[1])
fault_lines = []
for (index,d) in perm_list:
fault_lines.append( self.__fault_lines[ index ])
self.__fault_lines = fault_lines
for line in self.__fault_lines:
x1,y1 = line.startPoint()
x2,y2 = line.endPoint()
d1 = x1 + b*(y1 - a)
d2 = x2 + b*(y2 - a)
if d1 > d2:
line.reverse()
def polyfit(n,x,y,s = None):
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 = cfunc.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 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 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 = BoolVector.createActiveList(ens_mask)
if len(active_list) > 0:
state = EnkfStateType.FORECAST
meas_data = MeasData(active_list)
obs_data = ObsData()
self.ert().getObservations().getObservationAndMeasureData(fs, local_obsdata, state, active_list, meas_data, obs_data)
meas_data.deactivateZeroStdSamples(obs_data)
active_size = len(obs_data)
if active_size > 0:
S = meas_data.createS(active_size)
D_obs = obs_data.createDobs(active_size)
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_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_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 _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_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 initX(self, A, S, R, dObs, E, D):
X = Matrix(A.columns(), A.columns())
self._initX(X, A, S, R, dObs, E, D)
return X
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 test_matrix_random_init(self):
m = Matrix(10,10)
rng = RandomNumberGenerator(RngAlgTypeEnum.MZRAN, RngInitModeEnum.INIT_DEFAULT)
m.randomInit( rng )
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 _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)])
