Java Basic2DMatrix类代码示例

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
@Override
public Matrix createRandomSymmetricMatrix(int size) {

    double array[][] = new double[size][size];

    Random rnd = new Random();

    for (int i = 0; i < size; i++) {
        for (int j = i; j < size; j++) {
            double value = rnd.nextDouble();
            array[i][j] = value;
            array[j][i] = value;
        }
    }

    return new Basic2DMatrix(array);
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
public static Matrix getEntityLabelSimMatrix(TokenizedDocument[] documents) {
    int entityCount = 0;
    for (int i = 0; i < documents.length; ++i) {
        entityCount += documents[i].entities.length;
    }
    String labels[] = new String[entityCount];
    entityCount = 0;
    for (int d = 0; d < documents.length; ++d) {
        for (int e = 0; e < documents[d].entities.length; ++e) {
            labels[entityCount] = documents[d].entities[e].label;
            ++entityCount;
        }
    }
    Matrix stringSimMatrix = new Basic2DMatrix(entityCount, entityCount);
    NGramDistance nGramDistance = new NGramDistance(3);
    double similarity;
    for (int i = 0; i < labels.length; ++i) {
        stringSimMatrix.set(i, i, 1);
        for (int j = i + 1; j < labels.length; ++j) {
            similarity = nGramDistance.getDistance(labels[i], labels[j]);
            stringSimMatrix.set(i, j, similarity);
            stringSimMatrix.set(j, i, similarity);
        }
    }
    return stringSimMatrix;
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
public static void run() {
    M = new Basic2DMatrix(new double[][] { { 5, 3, 0, 1 }, { 4, 0, 0, 1 }, { 1, 1, 0, 5 }, { 0, 1, 5, 4 } });
    SimpleMatrixDecomposition smd = new SimpleMatrixDecomposition();
    SimpleMatrixDecomposition.MAX_STEPS = 100;
    smd.decompose(M, 2);
    System.out.println(M);
    System.out.println(smd.getApproximation());

    CorrelationBasedDecomposition cbd = new CorrelationBasedDecomposition();
    CorrelationBasedDecomposition.MAX_STEPS = 100;
    cbd.decompose(M, 2);
    System.out.println(M);
    System.out.println(smd.getApproximation());

    AscendingCorrelationBasedDecomposition acd = new AscendingCorrelationBasedDecomposition();
    AscendingCorrelationBasedDecomposition.MAX_STEPS = 100;
    acd.decompose(M, 2);
    System.out.println(M);
    System.out.println(smd.getApproximation());
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
public TrainingResults train(String name, int numberOfTrees, List<LabeledItem<Integer>> trainingData, List<String> attributes, int defaultLabel) {
    int featuresToUse = (int) Math.sqrt(attributes.size());

    Multimap<LabeledItem<Integer>, Tree<Integer>> treesForItem = Multimaps.synchronizedMultimap(ArrayListMultimap.create());
    Matrix itemProximities = new Basic2DMatrix(trainingData.size(), trainingData.size());
    IdentityHashMap<Tree<Integer>, Set<LabeledItem<Integer>>> outOfBagItemsByTree = new IdentityHashMap<>();
    Collection<Tree<Integer>> trees = Functional.timesParallel(numberOfTrees, () -> {
        List<LabeledItem<Integer>> bootstrappedData = pickTrainingData(trainingData);
        Set<LabeledItem<Integer>> outOfBagItems = Sets.difference(new HashSet<>(trainingData), new HashSet<>(bootstrappedData));
        Tree<Integer> tree = decisionTreeTrainer.train(name, bootstrappedData, attributes, featuresToUse, defaultLabel);
        outOfBagItems.forEach(item -> treesForItem.put(item, tree));
        outOfBagItemsByTree.put(tree, outOfBagItems);
        System.out.print(".");
        return tree;
    });

    System.out.println("\n calculating proximities...");
    calculateProximities(trainingData, itemProximities, trees);

    return new TrainingResults(new RandomForest(trees, defaultLabel), treesForItem, itemProximities, trainingData, outOfBagItemsByTree);
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
/**
 * Returns a cover containing the membership degrees of all nodes.,
 * calculated from
 * 
 * @param graph The graph which is being analyzed.
 * 
 * @param communities A mapping from the leader nodes to the iteration count
 * mapping of their community members.
 * 
 * @return A cover containing each nodes membership degree
 */
protected Cover getMembershipDegrees(CustomGraph graph,
		Map<Node, Map<Node, Integer>> communities) throws InterruptedException {
	Matrix membershipMatrix = new Basic2DMatrix(graph.nodeCount(),
			communities.size());
	int communityIndex = 0;
	double membershipDegree;
	for (Node leader : communities.keySet()) {
		if(Thread.interrupted()) {
			throw new InterruptedException();
		}
		membershipMatrix.set(leader.index(), communityIndex, 1.0);
		for (Map.Entry<Node, Integer> entry : communities.get(leader)
				.entrySet()) {
			membershipDegree = 1.0 / Math.pow(entry.getValue(), 2);
			membershipMatrix.set(entry.getKey().index(), communityIndex,
					membershipDegree);
		}
		communityIndex++;
	}
	Cover cover = new Cover(graph, membershipMatrix);
	return cover;
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
/**
 * Returns a cover containing the membership degrees of all nodes.,
 * calculated from
 * 
 * @param graph The graph which is being analyzed.
 * 
 * @param communities A mapping from the leader nodes to the iteration count
 * mapping of their community members.
 * 
 * @return A cover containing each nodes membership degree
 */
protected Cover getMembershipDegrees(CustomGraph graph,
		Map<Node, Map<Node, Integer>> communities) throws InterruptedException {
	Matrix membershipMatrix = new Basic2DMatrix(graph.nodeCount(),
			communities.size());
	int communityIndex = 0;
	double membershipDegree;
	for (Node leader : communities.keySet()) {
		membershipMatrix.set(leader.index(), communityIndex, 1.0);
		for (Map.Entry<Node, Integer> entry : communities.get(leader)
				.entrySet()) {
			if(Thread.interrupted()) {
				throw new InterruptedException();
			}
			membershipDegree = 1.0 / Math.pow(entry.getValue(), 2);
			membershipMatrix.set(entry.getKey().index(), communityIndex,
					membershipDegree);
		}
		communityIndex++;
	}
	Cover cover = new Cover(graph, membershipMatrix);
	return cover;
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
@Test
public void testRandomWalkExecution() throws OcdAlgorithmException, InterruptedException {
	Matrix transitionMatrix = new Basic2DMatrix(2, 2);
	transitionMatrix.set(0, 0, 0.9);
	transitionMatrix.set(0, 1, 0.5);
	transitionMatrix.set(1, 0, 0.1);
	transitionMatrix.set(1, 1, 0.5);
	System.out.println("Transition Matrix:");
	System.out.println(transitionMatrix.transpose());
	BinarySearchRandomWalkLabelPropagationAlgorithm algo = new BinarySearchRandomWalkLabelPropagationAlgorithm();
	Map<String, String> parameters = new HashMap<String, String>();
	parameters.put(BinarySearchRandomWalkLabelPropagationAlgorithm.LEADERSHIP_ITERATION_BOUND_NAME, Integer.toString(1000));
	parameters.put(BinarySearchRandomWalkLabelPropagationAlgorithm.LEADERSHIP_PRECISION_FACTOR_NAME, Double.toString(0.001));
	algo.setParameters(parameters);
	Vector vec = algo.executeRandomWalk(transitionMatrix);
	System.out.println("Steady State Vector:");
	System.out.println(vec);
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
@Test
public void testRandomWalkExecution() throws OcdAlgorithmException, InterruptedException {
	Matrix transitionMatrix = new Basic2DMatrix(2, 2);
	transitionMatrix.set(0, 0, 0.9);
	transitionMatrix.set(0, 1, 0.5);
	transitionMatrix.set(1, 0, 0.1);
	transitionMatrix.set(1, 1, 0.5);
	System.out.println("Transition Matrix:");
	System.out.println(transitionMatrix.transpose());
	RandomWalkLabelPropagationAlgorithm algo = new RandomWalkLabelPropagationAlgorithm();
	Map<String, String> parameters = new HashMap<String, String>();
	parameters.put(RandomWalkLabelPropagationAlgorithm.PROFITABILITY_DELTA_NAME, Double.toString(0.05));
	parameters.put(RandomWalkLabelPropagationAlgorithm.LEADERSHIP_ITERATION_BOUND_NAME, Integer.toString(1000));
	parameters.put(RandomWalkLabelPropagationAlgorithm.LEADERSHIP_PRECISION_FACTOR_NAME, Double.toString(0.001));
	algo.setParameters(parameters);
	Vector vec = algo.executeRandomWalk(transitionMatrix);
	System.out.println("Steady State Vector:");
	System.out.println(vec);
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
public static CustomGraph getTinyCircleGraph() {
	// Initialization
	CustomGraph graph = new CustomGraph();
	Matrix memberships = new Basic2DMatrix(10, 2);
	// Creates 10 nodes.
	Node n[] = new Node[10];  
	for (int i = 0; i < 10; i++) {
		n[i] = graph.createNode();
		graph.setNodeName(n[i], "id: " + i);
		memberships.set(i, i%2, 1);
	}
	// Creates 10 edges forming a cycle
	Edge e[] = new Edge[10];
	for (int i = 0; i < 10; i++) {
		e[i] = graph.createEdge(n[i], n[(i+1)%10]);
		graph.setEdgeWeight(e[i], 1.0);
	}
	return new CustomGraph(graph);
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
/**
 * Method for returning the adjacency matrix for a given set of Nodes.
 *
 * <p>
 *     This adjacency matrix, A, is normalized such that every column
 *     sums to 1. This is done by dividing each entry of a column by the
 *     column's corresponding node's out degree. This gives us a
 *     column-stochastic matrix, a property we rely heavily on in the rest
 *     of the PageRank computation.
 *
 * @param idMap the mapping from integers to Node IDs
 * @param nodes the set of Nodes from which the matrix should be made
 * @return the adjacency matrix in Matrix form from package la4j
 */
private static Matrix getAdjMat(Map<Integer, Integer> idMap, Set<Node> nodes) {
    Matrix adjMatrix = new Basic2DMatrix(nodes.size(), nodes.size());
    for (Node node : nodes) {
        double cellEntry = 1 / (double) node.getOutDegree();
        Set<Edge> edges = node.getEdges();
        for (Edge e : edges) {
            adjMatrix.set(idMap.get(e.getTgt().getID()),
                    idMap.get(e.getSrc().getID()),
                    cellEntry);
        }
    }

    return adjMatrix;
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
public La4JDenseDoubleMatrix2D(Matrix source) {
	super(source.getRowCount(), source.getColumnCount());
	this.matrix = new Basic2DMatrix((int) source.getRowCount(), (int) source.getColumnCount());
	for (long[] c : source.availableCoordinates()) {
		setDouble(source.getAsDouble(c), c);
	}
	if (source.getMetaData() != null) {
		setMetaData(source.getMetaData().clone());
	}
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
public Matrix plus(double value) {
	Matrix result = new La4JDenseDoubleMatrix2D((Basic2DMatrix) matrix.add(value));
	MapMatrix<String, Object> a = getMetaData();
	if (a != null) {
		result.setMetaData(a.clone());
	}
	return result;
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
public Matrix mtimes(Matrix m) {
	if (m instanceof La4JDenseDoubleMatrix2D) {
		Matrix result = new La4JDenseDoubleMatrix2D(
				(Basic2DMatrix) matrix.multiply(((La4JDenseDoubleMatrix2D) m).matrix));
		return result;
	} else {
		return super.mtimes(m);
	}
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
public Matrix minus(double value) {
	Matrix result = new La4JDenseDoubleMatrix2D((Basic2DMatrix) matrix.subtract(value));
	MapMatrix<String, Object> a = getMetaData();
	if (a != null) {
		result.setMetaData(a.clone());
	}
	return result;
}
 

import org.la4j.matrix.dense.Basic2DMatrix; //导入依赖的package包/类
public Matrix divide(double value) {
	Matrix result = new La4JDenseDoubleMatrix2D((Basic2DMatrix) matrix.divide(value));
	MapMatrix<String, Object> a = getMetaData();
	if (a != null) {
		result.setMetaData(a.clone());
	}
	return result;
}