BE to AE and fixed time window options, remaining files

Author: leifeld

dna/src/main/java/dna/HeadlessDna.java

@@ -597,7 +597,7 @@ public void rTimeWindow(String networkType, String statementType, String variabl
 	}
 
 	/**
-	 * Compute a sequence of one-mode network matrices or a single one-mode network matrix, and compute their polarisation score(s) and diagnostics.
+	 * Compute a sequence of one-mode network matrices or a single one-mode network matrix, and compute their polarization score(s) and diagnostics.
 	 *
 	 * @param statementType      Statement type as a {@link String}.
 	 * @param variable1          First variable for export, provided as a {@link String}.
@@ -623,17 +623,17 @@ public void rTimeWindow(String networkType, String statementType, String variabl
 	 * @param invertSources      boolean indicating whether the document-level source values should be included (= {@code true}) rather than excluded.
 	 * @param invertSections     boolean indicating whether the document-level section values should be included (= {@code true}) rather than excluded.
 	 * @param invertTypes        boolean indicating whether the document-level type values should be included (= {@code true}) rather than excluded.
-	 * @param algorithm          The algorithm to maximise polarisation at each time step. Can be "greedy" (for a greedy algorithm) or "genetic" (for a genetic algorithm).
-	 * @param normaliseScores    boolean indicating whether the polarisation scores should be normalised by dividing them by their theoretical maximum within a given network. This takes away the effect of more activity (possibly due to participation by more actors or more statements per actor) contributing to polarisation scores and focuses solely on structure given the edge mass in the network. Without normalisation, time periods with more actors and activity will elevate the polarisation of the network (at constant levels of being divided over concepts).
-	 * @param numClusters		 The number of clusters or factions k, for example 2 for bi-polarisation.
+	 * @param algorithm          The algorithm to maximise polarization at each time step. Can be "greedy" (for a greedy algorithm) or "genetic" (for a genetic algorithm).
+	 * @param normaliseScores    boolean indicating whether the polarization scores should be normalised by dividing them by their theoretical maximum within a given network. This takes away the effect of more activity (possibly due to participation by more actors or more statements per actor) contributing to polarization scores and focuses solely on structure given the edge mass in the network. Without normalisation, time periods with more actors and activity will elevate the polarization of the network (at constant levels of being divided over concepts).
+	 * @param numClusters		 The number of clusters or factions k, for example 2 for bi-polarization.
 	 * @param numParents         Only for the genetic algorithm: The number of cluster solutions (i.e., parents) to generate in each iteration, for example 30 or 50.
 	 * @param numterations       Only for the genetic algorithm: For how many generations should the genetic algorithm run at most? This is the maximal number of generations through which optimisation should be attempted. Will be lower if early convergence is detected. A suggested starting value is 1000.
 	 * @param elitePercentage    Only for the genetic algorithm: The share of cluster solutions in each parent generation that is copied into the children generation without changes, between 0.0 and 1.0, usually around 0.1.
 	 * @param mutationPercentage Only for the genetic algorithm: The probability with which each bit in any cluster solution is selected for mutation after the cross-over step. For example 0.1 to select 10% of the nodes to swap their memberships.
 	 * @param randomSeed         Only for the genetic algorithm: The random seed to use for the random number generator. Pass 0 for random behaviour.
-	 * @return                   A PolarisationResultTimeSeries object containing the results of the algorithm for each time step and iteration.
+	 * @return                   A PolarizationResultTimeSeries object containing the results of the algorithm for each time step and iteration.
 	 */
-	public PolarisationResultTimeSeries rPolarisation(String statementType, String variable1, boolean variable1Document,
+	public PolarizationResultTimeSeries rPolarization(String statementType, String variable1, boolean variable1Document,
 			String variable2, boolean variable2Document, String qualifier, String duplicates, String startDate,
 			String stopDate, String timeWindow, int windowSize, String kernel, boolean indentTime,
 			String[] excludeVariables, String[] excludeValues, String[] excludeAuthors, String[] excludeSources,
@@ -667,13 +667,13 @@ public PolarisationResultTimeSeries rPolarisation(String statementType, String v
 			}
 		}
 
-		Polarisation polarisation = new Polarisation(st, variable1, variable1Document, variable2, variable2Document,
+		Polarization polarization = new Polarization(st, variable1, variable1Document, variable2, variable2Document,
 				qualifier, false, duplicates, ldtStart, ldtStop, timeWindow, windowSize, kernel, indentTime,
 				map, excludeAuthors, excludeSources,	excludeSections, excludeTypes, invertValues, invertAuthors,
 				invertSources, invertSections, invertTypes, algorithm, normaliseScores, numClusters, numParents,
 				numIterations, elitePercentage, mutationPercentage, randomSeed);
 
-		return polarisation.getResults();
+		return polarization.getResults();
 	}
 
 	/**

dna/src/main/java/dna/export/Exporter.java

@@ -3385,7 +3385,7 @@ public void initializeNestedBackbone() {
 		fullMatrix = this.computeOneModeMatrix(this.filteredStatements, this.qualifierAggregation, this.startDateTime, this.stopDateTime);
 		this.isolates = true; // include isolates in the iterations but not in the full matrix; will be adjusted to smaller full matrix dimensions without isolates manually each time in the iterations; necessary because some actors may be deleted in the backbone matrix otherwise after deleting their concepts
 
-		// compute normalised eigenvalues for the full matrix; no need to recompute every time as they do not change
+		// compute normalized eigenvalues for the full matrix; no need to recompute every time as they do not change
 		eigenvaluesFull = computeNormalizedEigenvalues(fullMatrix.getMatrix(), "ojalgo");
 		iteration = new int[fullConcepts.length];
 		backboneLoss = new double[fullConcepts.length];
@@ -3422,7 +3422,7 @@ public void iterateNestedBackbone() {
 			candidateMatrix = this.computeOneModeMatrix(candidateStatementList, this.qualifierAggregation, this.startDateTime, this.stopDateTime);
 			candidateMatrix = this.reduceCandidateMatrix(candidateMatrix, fullMatrix.getRowNames()); // ensure it has the right dimensions by purging isolates relative to the full matrix
 			candidateMatrices.add(candidateMatrix);
-			eigenvaluesCandidate = computeNormalizedEigenvalues(candidateMatrix.getMatrix(), "ojalgo"); // normalised eigenvalues for the candidate matrix
+			eigenvaluesCandidate = computeNormalizedEigenvalues(candidateMatrix.getMatrix(), "ojalgo"); // normalized eigenvalues for the candidate matrix
 			currentLosses[i] = spectralLoss(eigenvaluesFull, eigenvaluesCandidate);
 		}
 		double smallestLoss = 0.0;
@@ -3505,7 +3505,7 @@ public void initializeSimulatedAnnealingBackbone(boolean penalty, double p, int
 		fullMatrix = this.computeOneModeMatrix(this.filteredStatements, this.qualifierAggregation, this.startDateTime, this.stopDateTime);
 		this.isolates = true; // include isolates in the iterations; will be adjusted to full matrix without isolates manually each time
 
-		// compute normalised eigenvalues for the full matrix; no need to recompute every time as they do not change
+		// compute normalized eigenvalues for the full matrix; no need to recompute every time as they do not change
 		eigenvaluesFull = computeNormalizedEigenvalues(fullMatrix.getMatrix(), "ojalgo");
 
 		if (penalty) { // simulated annealing with penalty: initially one randomly chosen entity in the backbone set
@@ -3558,7 +3558,7 @@ public void initializeSimulatedAnnealingBackbone(boolean penalty, double p, int
 		finalMatrix = this.reduceCandidateMatrix(finalMatrix, fullMatrix.getRowNames()); // ensure it has the right dimensions by purging isolates relative to the full matrix
 
 		// eigenvalues for final matrix
-		eigenvaluesFinal = computeNormalizedEigenvalues(finalMatrix.getMatrix(), "ojalgo"); // normalised eigenvalues for the candidate matrix
+		eigenvaluesFinal = computeNormalizedEigenvalues(finalMatrix.getMatrix(), "ojalgo"); // normalized eigenvalues for the candidate matrix
 
 		// create an initial current backbone set B_0, also with the one c_j concept like in B: B_0 <- {c_j}
 		currentBackboneList = new ArrayList<String>(finalBackboneList);
@@ -3671,7 +3671,7 @@ public void iterateSimulatedAnnealingBackbone(boolean penalty) {
 				.collect(Collectors.toCollection(ArrayList::new));
 		candidateMatrix = this.computeOneModeMatrix(candidateStatementList, this.qualifierAggregation, this.startDateTime, this.stopDateTime); // create candidate matrix after filtering the statements based on the action that was executed
 		candidateMatrix = this.reduceCandidateMatrix(candidateMatrix, fullMatrix.getRowNames()); // ensure it has the right dimensions by purging isolates relative to the full matrix
-		eigenvaluesCandidate = computeNormalizedEigenvalues(candidateMatrix.getMatrix(), "ojalgo"); // normalised eigenvalues for the candidate matrix
+		eigenvaluesCandidate = computeNormalizedEigenvalues(candidateMatrix.getMatrix(), "ojalgo"); // normalized eigenvalues for the candidate matrix
 		if (penalty) {
 			newLoss = penalizedLoss(eigenvaluesFull, eigenvaluesCandidate, p, candidateBackboneList.size(), fullConcepts.length); // spectral distance between full and candidate matrix
 		} else {
@@ -3749,7 +3749,7 @@ public double[] evaluateBackboneSolution(String[] backboneEntities, int p) {
 		fullMatrix = this.computeOneModeMatrix(this.filteredStatements, this.qualifierAggregation, this.startDateTime, this.stopDateTime);
 		this.isolates = true; // include isolates in the iterations; will be adjusted to full matrix without isolates manually each time
 
-		// compute normalised eigenvalues for the full matrix; no need to recompute every time as they do not change
+		// compute normalized eigenvalues for the full matrix; no need to recompute every time as they do not change
 		eigenvaluesFull = computeNormalizedEigenvalues(fullMatrix.getMatrix(), "ojalgo");
 
 		// create copy of filtered statements and remove redundant entities
@@ -3771,7 +3771,7 @@ public double[] evaluateBackboneSolution(String[] backboneEntities, int p) {
 				.collect(Collectors.toCollection(ArrayList::new));
 		candidateMatrix = this.computeOneModeMatrix(candidateStatementList, this.qualifierAggregation, this.startDateTime, this.stopDateTime); // create candidate matrix after filtering the statements based on the action that was executed
 		candidateMatrix = this.reduceCandidateMatrix(candidateMatrix, fullMatrix.getRowNames()); // ensure it has the right dimensions by purging isolates relative to the full matrix
-		eigenvaluesCandidate = computeNormalizedEigenvalues(candidateMatrix.getMatrix(), "ojalgo"); // normalised eigenvalues for the candidate matrix
+		eigenvaluesCandidate = computeNormalizedEigenvalues(candidateMatrix.getMatrix(), "ojalgo"); // normalized eigenvalues for the candidate matrix
 		results[0] = penalizedLoss(eigenvaluesFull, eigenvaluesCandidate, p, backboneSet.size(), fullConcepts.length); // spectral distance between full and candidate matrix
 
 		// spectral distance between full and redundant set
@@ -3781,7 +3781,7 @@ public double[] evaluateBackboneSolution(String[] backboneEntities, int p) {
 				.collect(Collectors.toCollection(ArrayList::new));
 		candidateMatrix = this.computeOneModeMatrix(candidateStatementList, this.qualifierAggregation, this.startDateTime, this.stopDateTime); // create candidate matrix after filtering the statements based on the action that was executed
 		candidateMatrix = this.reduceCandidateMatrix(candidateMatrix, fullMatrix.getRowNames()); // ensure it has the right dimensions by purging isolates relative to the full matrix
-		eigenvaluesCandidate = computeNormalizedEigenvalues(candidateMatrix.getMatrix(), "ojalgo"); // normalised eigenvalues for the candidate matrix
+		eigenvaluesCandidate = computeNormalizedEigenvalues(candidateMatrix.getMatrix(), "ojalgo"); // normalized eigenvalues for the candidate matrix
 		results[1] = penalizedLoss(eigenvaluesFull, eigenvaluesCandidate, p, redundantSet.size(), fullConcepts.length); // spectral distance between full and candidate matrix
 
 		return results;

dna/src/main/java/dna/export/Matrix.java

@@ -26,6 +26,12 @@ public Matrix(double[][] matrix, String[] rowNames, String[] columnNames, boolea
 		this.integer = integer;
 		this.start = start;
 		this.stop = stop;
+
+		// calculate the mid-point date/time
+		long startEpoch = start.toEpochSecond(ZoneOffset.UTC);
+        long endEpoch = stop.toEpochSecond(ZoneOffset.UTC);
+        long midpointEpoch = (startEpoch + endEpoch) / 2; // Average of timestamps
+		this.dateTime = LocalDateTime.ofEpochSecond(midpointEpoch, 0, ZoneOffset.UTC);
 	}
 
 	/**