matrix1.java

是实现关系型贝叶斯网络一中机器学习算法

package rmn;

import java.util.*;

public class Matrix1 implements Matrix {

  public double[] m_matrix;

  public Matrix1()
  {
  }

  public Matrix1(int nCard)
  {
    m_matrix = new double[nCard];
  }

  public Matrix1(double[] matrix)
  {
    m_matrix = matrix;
  }

  public Matrix1(Matrix1 matrix1)
  {
    m_matrix = new double[matrix1.m_matrix.length];
    System.arraycopy(matrix1.m_matrix, 0, m_matrix, 0, matrix1.m_matrix.length);
  }

  public Matrix getCopy()
  {
    return new Matrix1(this);
  }

  public Matrix newMatrix()
  {
    return new Matrix1(m_matrix.length);
  }

  public void fill(double val)
  {
    Arrays.fill(m_matrix, val);
  }

  public int size()
  {
    return 1;
  }

  public int[] getDimensions()
  {
    int[] dims = new int[1];
    dims[0] = m_matrix.length;

    return dims; 
  }

  public void inc(int[] pos)
  {
    assert pos.length == size() : pos.length;

    m_matrix[pos[0]]++;
  }


  public void add_sub(Matrix matrix1, Matrix matrix2, double rate)
  {
    Matrix1 m1 =  (Matrix1) matrix1;
    Matrix1 m2 =  (Matrix1) matrix2;

    // dimensions should match
    assert m1.m_matrix.length == m_matrix.length : m1.m_matrix.length;
    assert m2.m_matrix.length == m_matrix.length : m2.m_matrix.length;

    for (int i = 0; i < m_matrix.length; i++) {
      double grad = (m1.m_matrix[i] - m2.m_matrix[i]) * rate;
      m_matrix[i] = m_matrix[i] * Math.exp(grad);
      assert !Double.isNaN(m_matrix[i]) : grad;
      assert !Double.isInfinite(m_matrix[i]) : grad;
    }
  }

  public void add_log(Matrix matrix, int delta)
  {
    Matrix1 m =  (Matrix1) matrix;
    for (int i = 0; i < m_matrix.length; i++) {
      m_matrix[i] = m_matrix[i] + delta * Math.log(m.m_matrix[i]);
    }
  }

  public Matrix exp_avg(int n)
  {
    Matrix1 m = (Matrix1) newMatrix();
    for (int i = 0; i < m_matrix.length; i++) {
      m.m_matrix[i] = Math.exp(m_matrix[i] / n);
    }
    
    return m;
  }

  public void dotProduct(Matrix matrix)
  {
    Matrix1 matrix1 =  (Matrix1) matrix;

    // dimensions should match
    assert matrix1.m_matrix.length == m_matrix.length : matrix1.m_matrix.length;

    for (int i = 0; i < m_matrix.length; i++) {
      m_matrix[i] = m_matrix[i] * matrix1.m_matrix[i];
      assert !Double.isNaN(m_matrix[i]);
      assert !Double.isInfinite(m_matrix[i]);
    }
  }

  public void dotProduct(double[] vector, int dim)
  {
    assert dim < size() : dim;
    assert vector.length == m_matrix.length : vector.length;

    for (int i = 0; i < m_matrix.length; i++) {
      m_matrix[i] = m_matrix[i] * vector[i];
      assert !Double.isNaN(m_matrix[i]);
      assert !Double.isInfinite(m_matrix[i]);
    }
  }

  public void dotQuotient(double[] vector, int dim)
  {
    assert dim < size() : dim;
    assert vector.length == m_matrix.length : vector.length;

    for (int i = 0; i < m_matrix.length; i++) {
      m_matrix[i] = m_matrix[i] / vector[i];
      assert vector[i] != 0;
    }
  }
  
  public double[] marginalize(int dim, boolean bMaximize)
  {
     assert dim < size() : dim;

     double[] margin = new double[m_matrix.length];
     System.arraycopy(m_matrix, 0, margin, 0, m_matrix.length);

     return margin;
  }

  public String toString()
  {
    String strRes = new String();
    for (int i = 0; i < m_matrix.length; i++)
      strRes += String.valueOf(m_matrix[i]) + " ";

    return strRes;
  }

}