simplefuzzymatrix.java

dm s preparing process. In this case we use O distance.

/* created at 2005-12-23 */
package com.clustering.core;

import java.io.CharArrayWriter;
import java.io.PrintWriter;

import com.clustering.core.support.DistanceCalcutation;
import com.clustering.core.support.EuclideanCalculation;
import com.clustering.core.support.PValueCalculation;
import com.clustering.data.SimpleSource;
import com.clustering.data.Source;
import com.clustering.ds.graph.Graph;
import com.clustering.ds.matrix.SimpleSymetricalMatrix;

/**
 * 165跳 模糊相似矩阵.
 * <p>
 * 模糊相似矩阵不属于经典数据结构，所以放到这个包中。该类的实现很别扭，只是启到概念上的占位作用
 * <p>
 * 
 * @author Avon
 * @version 0.9
 * @since 0.9 备注：
 *        并没有为SimpleFuzzyMatrix创建工厂，认为SimpleFuzzyMatrix既然是一个对称矩阵，那么应该继承SimpleSymetricalMatrix，
 *        因此不能把SimpleFuzzyMatrix作为接口实现，作为一个类,SimpleFuzzyMatrix的构造函数完全可以创建该类对象，只是构造函数中应该支持
 *        DataSource的重载版本也就是这个类的构造函数3。因此没有必要为这个类创建工厂，ComplexSymetricalMatrix也是一样，也就没有为这两个类
 *        创建工厂
 *        总之没有创建工厂的主要原因是SimpleFuzzyMatrix是SimpleSymetricalMatrix的派生类，所以SimpleFuzzyMatrix是类而不是接口。因此
 *        没有必要为这个类创建工厂 这个类虽然也有init方法，但是init方法并被使用者调用，因此没有必要为这个类实现Factory
 */
public class SimpleFuzzyMatrix extends SimpleSymetricalMatrix {
	private Source source;

	private DistanceCalcutation calc;

	// 5.3.3.2中的p
	private double P;

	PValueCalculation pcalc;

	@Deprecated
	public SimpleFuzzyMatrix() {
		super();
	}

	@SuppressWarnings("deprecation")
	public SimpleFuzzyMatrix(Source source) {
		super(source.getSourceInfo().getRecordNum());
		this.source = source;
		checkSimpleSource(source);
		calc = new EuclideanCalculation();
		P = 1;
		pcalc = null;
		init();
	}

	@SuppressWarnings("deprecation")
	public SimpleFuzzyMatrix(Source source, DistanceCalcutation calcutation) {
		super(source.getSourceInfo().getRecordNum());
		this.source = source;
		checkSimpleSource(source);
		if (null == calc)
			calc = new EuclideanCalculation();
		else
			this.calc = calcutation;
		P = 1;
		pcalc = null;
		init();
	}

	public SimpleFuzzyMatrix(Source source, DistanceCalcutation calcutation, double p) {
		super(source.getSourceInfo().getRecordNum());
		this.source = source;
		checkSimpleSource(source);
		if (null == calc)
			calc = new EuclideanCalculation();
		else
			this.calc = calcutation;
		P = p;
		pcalc = null;
		init();
	}

	public SimpleFuzzyMatrix(Source source, DistanceCalcutation calcutation, PValueCalculation pcalc) {
		super(source.getSourceInfo().getRecordNum());
		this.source = source;
		checkSimpleSource(source);
		if (null == calc)
			calc = new EuclideanCalculation();
		else
			this.calc = calcutation;
		this.pcalc = pcalc;
		P = 0;
		init();
	}

	private void checkSimpleSource(Source source) {
		boolean isSimpleSouce = false;
		Class cls = source.getClass();
		if (SimpleSource.class.isAssignableFrom(cls)) {
			isSimpleSouce = true;
		}
		if (!isSimpleSouce) {
			throw new UnsupportedClassVersionError(
					"Current version only support FileSystemSourceFactory$SimpleFileSystemSourceImpl. "
							+ "If u have implemented a new SimpleSource, modify method "
							+ "SimpleFuzzyMatrix#SimpleFuzzyMatrix(Source).");
		}
	}

	/*
	 * 这个方法用来根据数据源初始化对称矩阵
	 */
	private void init() {
		// 初始化对角线
		for (int i = 0; i < bound; i++)
			super.setElement(i, i, new Double(1));

		// 初始化一半矩阵
		for (int i = 0; i < bound; i++) {
			for (int j = 0; j < i; j++) {
				// problem 5.3.3.2r[i,j] = 1 - p*d[i,j]，这里只求出了d[i,j]还没有求出p
				double distance = new Double(calc.getDistance(source.getRecord(i), source.getRecord(j)));
				super.setElement(i, j, distance);
			}
		}
		if (null != pcalc) {
			while (!pcalc.isOK()) {
				P = pcalc.getNextP(values);
			}
		}
	}

	public DistanceCalcutation getDistanceCalcutation() {
		return calc;
	}

	public void setDistanceCalcutation(DistanceCalcutation calcutation) {
		this.calc = calcutation;
	}

	public double getP() {
		return P;
	}

	public Source getSource() {
		return source;
	}

	/**
	 * 使用这个方法的方式是"在{@link SimpleFuzzyMatrix(Source)}或{@link SimpleFuzzyMatrix(Source , DistanceCalcutation}"
	 * 中没有指定数据源，如果在构造函数中指定了数据源就不要使用这个方法再指定数据源
	 * 
	 * @param source
	 *            SimpleFuzzyMatrix将包装的数据源
	 */
	public void setSource(Source source) {
		this.source = source;
		init();
	}

	@Override
	public Double getElement(long row, long col) {
		return new Double(1 - P * ((Double) super.getElement(row, col)).doubleValue());
	}

	/*
	 * 这个方法可真别扭啊
	 */
	public Double getDistance(long row, long col) {
		return ((Double) super.getElement(row, col));
	}

	@Override
	@Deprecated
	public void setElement(long row, long col, Object value) {
		throw new UnsupportedOperationException("SimpleFuzzyMatrix for mining is allowed to modified.");
	}

	@Override
	@Deprecated
	public void setBound(long bound) {
		throw new UnsupportedOperationException("SimpleFuzzyMatrix for mining is allowed to modified.");
	}

	public Graph toGraph() {
		return new SimpleFuzzyGraph(this);
	}

	/**
	 * 让values对SimpleFuzzyGraph、SimpleGeneratingTree可见
	 * 
	 * @return
	 */
	Object[] values() {
		return values;
	}

	public String distanceMatrixToString(boolean upper) {
		CharArrayWriter cWriter = new CharArrayWriter();
		PrintWriter out = new PrintWriter(cWriter);
		out.print("The distance matrix is a ");
		out.print(bound);
		out.print('*');
		out.print(bound);
		out.print(" matrix which is Symetrical Matrix. Here we simply show");
		/*
		 * r > c { r * (r + 1) / 2 + c; } r < c { c * (c + 1) / 2 + r; }
		 */
		if (upper) {
			out.println(" upper triangle matrix with colum in priority and omit diagonal elements.");
			for (int i = 0; i < bound; i++) {
				for (int j = i + 1; j < bound; j++) {
					out.printf("[%d, %d]:\t\t%.3f", i, j, values[j * (j + 1) / 2 + i]);
					out.println();
				}
				out.println();
			}
		} else {
			out.println(" lower triangle matrix with row in priority and omit diagonal elements.");
			for (int j = 0; j < bound; j++) {
				for (int i = j + 1; i < bound; i++) {
					out.printf("[%d, %d]:\t\t%.3f", i, j, values[i * (i + 1) / 2 + j]);
					out.println();
				}
				out.println();
			}
		}
		out.close();
		cWriter.close();
		return cWriter.toString();
	}

	public String fuzzyMatrixToString(boolean upper) {
		CharArrayWriter cWriter = new CharArrayWriter();
		PrintWriter out = new PrintWriter(cWriter);
		out.print("The fuzzy similar matrix is a ");
		out.print(bound);
		out.print('*');
		out.print(bound);
		out.print(" matrix which is Symetrical Matrix and standardized with ");
		if (null == pcalc) {
			out.print(P);
			out.print("[P value].");
		} else {
			out.print(pcalc.getClass().getSimpleName());
			if (pcalc.isLog()) {
				out.print(". The log info of ");
				out.print(pcalc.getClass().getSimpleName());
				out.println(":");
				out.println(pcalc.getLog());
			}
		}
		out.print("Here we simply show");
		/*
		 * r > c { r * (r + 1) / 2 + c; } r < c { c * (c + 1) / 2 + r; }
		 */
		if (upper) {
			out.println(" upper triangle matrix with colum in priority and omit diagonal elements.");
			for (int i = 0; i < bound; i++) {
				for (int j = i + 1; j < bound; j++) {
					out.printf("[%d, %d]:\t\t%.3f", i, j, 1 - P * ((Double) values[j * (j + 1) / 2 + i]).doubleValue());
					out.println();
				}
				out.println();
			}
		} else {
			out.println(" lower triangle matrix with row in priority and omit diagonal elements.");
			for (int j = 0; j < bound; j++) {
				for (int i = j + 1; i < bound; i++) {
					out.printf("[%d, %d]:\t\t%.3f", i, j, 1 - P
							* ((Double) (values[i * (i + 1) / 2 + j])).doubleValue());
					out.println();
				}
				out.println();
			}
		}
		out.close();
		cWriter.close();
		return cWriter.toString();
	}

}