Ejemplo n.º 1
0
    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)
Ejemplo n.º 2
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])
Ejemplo n.º 3
0
    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
Ejemplo n.º 4
0
    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