mirror of
https://github.com/Pinball3D/Rabbit-R1.git
synced 2024-12-30 11:02:31 -06:00
891 lines
34 KiB
Java
891 lines
34 KiB
Java
|
package androidx.constraintlayout.solver;
|
||
|
|
|
||
|
|
import androidx.constraintlayout.solver.SolverVariable;
|
||
|
|
import androidx.constraintlayout.solver.widgets.ConstraintAnchor;
|
||
|
|
import androidx.constraintlayout.solver.widgets.ConstraintWidget;
|
||
|
|
import io.sentry.protocol.ViewHierarchyNode;
|
||
|
|
import java.io.PrintStream;
|
||
|
|
import java.util.Arrays;
|
||
|
|
import java.util.HashMap;
|
||
|
|
|
||
|
|
/* loaded from: classes.dex */
|
||
|
|
public class LinearSystem {
|
||
|
|
public static long ARRAY_ROW_CREATION = 0;
|
||
|
|
public static final boolean DEBUG = false;
|
||
|
|
private static final boolean DEBUG_CONSTRAINTS = false;
|
||
|
|
public static final boolean FULL_DEBUG = false;
|
||
|
|
public static final boolean MEASURE = false;
|
||
|
|
public static long OPTIMIZED_ARRAY_ROW_CREATION = 0;
|
||
|
|
public static boolean OPTIMIZED_ENGINE = true;
|
||
|
|
private static int POOL_SIZE = 1000;
|
||
|
|
static final boolean SIMPLIFY_SYNONYMS = false;
|
||
|
|
private static final boolean USE_SYNONYMS = true;
|
||
|
|
public static Metrics sMetrics;
|
||
|
|
final Cache mCache;
|
||
|
|
private Row mGoal;
|
||
|
|
ArrayRow[] mRows;
|
||
|
|
private Row mTempGoal;
|
||
|
|
int mVariablesID = 0;
|
||
|
|
private HashMap<String, SolverVariable> mVariables = null;
|
||
|
|
private int TABLE_SIZE = 32;
|
||
|
|
private int mMaxColumns = 32;
|
||
|
|
public boolean graphOptimizer = false;
|
||
|
|
public boolean newgraphOptimizer = false;
|
||
|
|
private boolean[] mAlreadyTestedCandidates = new boolean[32];
|
||
|
|
int mNumColumns = 1;
|
||
|
|
int mNumRows = 0;
|
||
|
|
private int mMaxRows = 32;
|
||
|
|
private SolverVariable[] mPoolVariables = new SolverVariable[POOL_SIZE];
|
||
|
|
private int mPoolVariablesCount = 0;
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
||
|
|
/* loaded from: classes.dex */
|
||
|
|
public interface Row {
|
||
|
|
void addError(SolverVariable solverVariable);
|
||
|
|
|
||
|
|
void clear();
|
||
|
|
|
||
|
|
SolverVariable getKey();
|
||
|
|
|
||
|
|
SolverVariable getPivotCandidate(LinearSystem linearSystem, boolean[] zArr);
|
||
|
|
|
||
|
|
void initFromRow(Row row);
|
||
|
|
|
||
|
|
boolean isEmpty();
|
||
|
|
|
||
|
|
void updateFromFinalVariable(LinearSystem linearSystem, SolverVariable solverVariable, boolean z);
|
||
|
|
|
||
|
|
void updateFromRow(ArrayRow arrayRow, boolean z);
|
||
|
|
|
||
|
|
void updateFromSystem(LinearSystem linearSystem);
|
||
|
|
}
|
||
|
|
|
||
|
|
private String getDisplayStrength(int i) {
|
||
|
|
return i == 1 ? "LOW" : i == 2 ? "MEDIUM" : i == 3 ? "HIGH" : i == 4 ? "HIGHEST" : i == 5 ? "EQUALITY" : i == 8 ? "FIXED" : i == 6 ? "BARRIER" : "NONE";
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Metrics getMetrics() {
|
||
|
|
return sMetrics;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void fillMetrics(Metrics metrics) {
|
||
|
|
sMetrics = metrics;
|
||
|
|
}
|
||
|
|
|
||
|
|
public Cache getCache() {
|
||
|
|
return this.mCache;
|
||
|
|
}
|
||
|
|
|
||
|
|
Row getGoal() {
|
||
|
|
return this.mGoal;
|
||
|
|
}
|
||
|
|
|
||
|
|
public int getNumEquations() {
|
||
|
|
return this.mNumRows;
|
||
|
|
}
|
||
|
|
|
||
|
|
public int getNumVariables() {
|
||
|
|
return this.mVariablesID;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
||
|
|
/* loaded from: classes.dex */
|
||
|
|
public class ValuesRow extends ArrayRow {
|
||
|
|
public ValuesRow(Cache cache) {
|
||
|
|
this.variables = new SolverVariableValues(this, cache);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public LinearSystem() {
|
||
|
|
this.mRows = null;
|
||
|
|
this.mRows = new ArrayRow[32];
|
||
|
|
releaseRows();
|
||
|
|
Cache cache = new Cache();
|
||
|
|
this.mCache = cache;
|
||
|
|
this.mGoal = new PriorityGoalRow(cache);
|
||
|
|
if (OPTIMIZED_ENGINE) {
|
||
|
|
this.mTempGoal = new ValuesRow(cache);
|
||
|
|
} else {
|
||
|
|
this.mTempGoal = new ArrayRow(cache);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void increaseTableSize() {
|
||
|
|
int i = this.TABLE_SIZE * 2;
|
||
|
|
this.TABLE_SIZE = i;
|
||
|
|
this.mRows = (ArrayRow[]) Arrays.copyOf(this.mRows, i);
|
||
|
|
Cache cache = this.mCache;
|
||
|
|
cache.mIndexedVariables = (SolverVariable[]) Arrays.copyOf(cache.mIndexedVariables, this.TABLE_SIZE);
|
||
|
|
int i2 = this.TABLE_SIZE;
|
||
|
|
this.mAlreadyTestedCandidates = new boolean[i2];
|
||
|
|
this.mMaxColumns = i2;
|
||
|
|
this.mMaxRows = i2;
|
||
|
|
Metrics metrics = sMetrics;
|
||
|
|
if (metrics != null) {
|
||
|
|
metrics.tableSizeIncrease++;
|
||
|
|
Metrics metrics2 = sMetrics;
|
||
|
|
metrics2.maxTableSize = Math.max(metrics2.maxTableSize, this.TABLE_SIZE);
|
||
|
|
Metrics metrics3 = sMetrics;
|
||
|
|
metrics3.lastTableSize = metrics3.maxTableSize;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void releaseRows() {
|
||
|
|
int i = 0;
|
||
|
|
if (OPTIMIZED_ENGINE) {
|
||
|
|
while (true) {
|
||
|
|
ArrayRow[] arrayRowArr = this.mRows;
|
||
|
|
if (i >= arrayRowArr.length) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ArrayRow arrayRow = arrayRowArr[i];
|
||
|
|
if (arrayRow != null) {
|
||
|
|
this.mCache.optimizedArrayRowPool.release(arrayRow);
|
||
|
|
}
|
||
|
|
this.mRows[i] = null;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
while (true) {
|
||
|
|
ArrayRow[] arrayRowArr2 = this.mRows;
|
||
|
|
if (i >= arrayRowArr2.length) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ArrayRow arrayRow2 = arrayRowArr2[i];
|
||
|
|
if (arrayRow2 != null) {
|
||
|
|
this.mCache.arrayRowPool.release(arrayRow2);
|
||
|
|
}
|
||
|
|
this.mRows[i] = null;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void reset() {
|
||
|
|
for (int i = 0; i < this.mCache.mIndexedVariables.length; i++) {
|
||
|
|
SolverVariable solverVariable = this.mCache.mIndexedVariables[i];
|
||
|
|
if (solverVariable != null) {
|
||
|
|
solverVariable.reset();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.mCache.solverVariablePool.releaseAll(this.mPoolVariables, this.mPoolVariablesCount);
|
||
|
|
this.mPoolVariablesCount = 0;
|
||
|
|
Arrays.fill(this.mCache.mIndexedVariables, (Object) null);
|
||
|
|
HashMap<String, SolverVariable> hashMap = this.mVariables;
|
||
|
|
if (hashMap != null) {
|
||
|
|
hashMap.clear();
|
||
|
|
}
|
||
|
|
this.mVariablesID = 0;
|
||
|
|
this.mGoal.clear();
|
||
|
|
this.mNumColumns = 1;
|
||
|
|
for (int i2 = 0; i2 < this.mNumRows; i2++) {
|
||
|
|
this.mRows[i2].used = false;
|
||
|
|
}
|
||
|
|
releaseRows();
|
||
|
|
this.mNumRows = 0;
|
||
|
|
if (OPTIMIZED_ENGINE) {
|
||
|
|
this.mTempGoal = new ValuesRow(this.mCache);
|
||
|
|
} else {
|
||
|
|
this.mTempGoal = new ArrayRow(this.mCache);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public SolverVariable createObjectVariable(Object obj) {
|
||
|
|
SolverVariable solverVariable = null;
|
||
|
|
if (obj == null) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if (this.mNumColumns + 1 >= this.mMaxColumns) {
|
||
|
|
increaseTableSize();
|
||
|
|
}
|
||
|
|
if (obj instanceof ConstraintAnchor) {
|
||
|
|
ConstraintAnchor constraintAnchor = (ConstraintAnchor) obj;
|
||
|
|
solverVariable = constraintAnchor.getSolverVariable();
|
||
|
|
if (solverVariable == null) {
|
||
|
|
constraintAnchor.resetSolverVariable(this.mCache);
|
||
|
|
solverVariable = constraintAnchor.getSolverVariable();
|
||
|
|
}
|
||
|
|
if (solverVariable.id == -1 || solverVariable.id > this.mVariablesID || this.mCache.mIndexedVariables[solverVariable.id] == null) {
|
||
|
|
if (solverVariable.id != -1) {
|
||
|
|
solverVariable.reset();
|
||
|
|
}
|
||
|
|
int i = this.mVariablesID + 1;
|
||
|
|
this.mVariablesID = i;
|
||
|
|
this.mNumColumns++;
|
||
|
|
solverVariable.id = i;
|
||
|
|
solverVariable.mType = SolverVariable.Type.UNRESTRICTED;
|
||
|
|
this.mCache.mIndexedVariables[this.mVariablesID] = solverVariable;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return solverVariable;
|
||
|
|
}
|
||
|
|
|
||
|
|
public ArrayRow createRow() {
|
||
|
|
ArrayRow acquire;
|
||
|
|
if (OPTIMIZED_ENGINE) {
|
||
|
|
acquire = this.mCache.optimizedArrayRowPool.acquire();
|
||
|
|
if (acquire == null) {
|
||
|
|
acquire = new ValuesRow(this.mCache);
|
||
|
|
OPTIMIZED_ARRAY_ROW_CREATION++;
|
||
|
|
} else {
|
||
|
|
acquire.reset();
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
acquire = this.mCache.arrayRowPool.acquire();
|
||
|
|
if (acquire == null) {
|
||
|
|
acquire = new ArrayRow(this.mCache);
|
||
|
|
ARRAY_ROW_CREATION++;
|
||
|
|
} else {
|
||
|
|
acquire.reset();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
SolverVariable.increaseErrorId();
|
||
|
|
return acquire;
|
||
|
|
}
|
||
|
|
|
||
|
|
public SolverVariable createSlackVariable() {
|
||
|
|
Metrics metrics = sMetrics;
|
||
|
|
if (metrics != null) {
|
||
|
|
metrics.slackvariables++;
|
||
|
|
}
|
||
|
|
if (this.mNumColumns + 1 >= this.mMaxColumns) {
|
||
|
|
increaseTableSize();
|
||
|
|
}
|
||
|
|
SolverVariable acquireSolverVariable = acquireSolverVariable(SolverVariable.Type.SLACK, null);
|
||
|
|
int i = this.mVariablesID + 1;
|
||
|
|
this.mVariablesID = i;
|
||
|
|
this.mNumColumns++;
|
||
|
|
acquireSolverVariable.id = i;
|
||
|
|
this.mCache.mIndexedVariables[this.mVariablesID] = acquireSolverVariable;
|
||
|
|
return acquireSolverVariable;
|
||
|
|
}
|
||
|
|
|
||
|
|
public SolverVariable createExtraVariable() {
|
||
|
|
Metrics metrics = sMetrics;
|
||
|
|
if (metrics != null) {
|
||
|
|
metrics.extravariables++;
|
||
|
|
}
|
||
|
|
if (this.mNumColumns + 1 >= this.mMaxColumns) {
|
||
|
|
increaseTableSize();
|
||
|
|
}
|
||
|
|
SolverVariable acquireSolverVariable = acquireSolverVariable(SolverVariable.Type.SLACK, null);
|
||
|
|
int i = this.mVariablesID + 1;
|
||
|
|
this.mVariablesID = i;
|
||
|
|
this.mNumColumns++;
|
||
|
|
acquireSolverVariable.id = i;
|
||
|
|
this.mCache.mIndexedVariables[this.mVariablesID] = acquireSolverVariable;
|
||
|
|
return acquireSolverVariable;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void addError(ArrayRow arrayRow) {
|
||
|
|
arrayRow.addError(this, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void addSingleError(ArrayRow arrayRow, int i) {
|
||
|
|
addSingleError(arrayRow, i, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
void addSingleError(ArrayRow arrayRow, int i, int i2) {
|
||
|
|
arrayRow.addSingleError(createErrorVariable(i2, null), i);
|
||
|
|
}
|
||
|
|
|
||
|
|
private SolverVariable createVariable(String str, SolverVariable.Type type) {
|
||
|
|
Metrics metrics = sMetrics;
|
||
|
|
if (metrics != null) {
|
||
|
|
metrics.variables++;
|
||
|
|
}
|
||
|
|
if (this.mNumColumns + 1 >= this.mMaxColumns) {
|
||
|
|
increaseTableSize();
|
||
|
|
}
|
||
|
|
SolverVariable acquireSolverVariable = acquireSolverVariable(type, null);
|
||
|
|
acquireSolverVariable.setName(str);
|
||
|
|
int i = this.mVariablesID + 1;
|
||
|
|
this.mVariablesID = i;
|
||
|
|
this.mNumColumns++;
|
||
|
|
acquireSolverVariable.id = i;
|
||
|
|
if (this.mVariables == null) {
|
||
|
|
this.mVariables = new HashMap<>();
|
||
|
|
}
|
||
|
|
this.mVariables.put(str, acquireSolverVariable);
|
||
|
|
this.mCache.mIndexedVariables[this.mVariablesID] = acquireSolverVariable;
|
||
|
|
return acquireSolverVariable;
|
||
|
|
}
|
||
|
|
|
||
|
|
public SolverVariable createErrorVariable(int i, String str) {
|
||
|
|
Metrics metrics = sMetrics;
|
||
|
|
if (metrics != null) {
|
||
|
|
metrics.errors++;
|
||
|
|
}
|
||
|
|
if (this.mNumColumns + 1 >= this.mMaxColumns) {
|
||
|
|
increaseTableSize();
|
||
|
|
}
|
||
|
|
SolverVariable acquireSolverVariable = acquireSolverVariable(SolverVariable.Type.ERROR, str);
|
||
|
|
int i2 = this.mVariablesID + 1;
|
||
|
|
this.mVariablesID = i2;
|
||
|
|
this.mNumColumns++;
|
||
|
|
acquireSolverVariable.id = i2;
|
||
|
|
acquireSolverVariable.strength = i;
|
||
|
|
this.mCache.mIndexedVariables[this.mVariablesID] = acquireSolverVariable;
|
||
|
|
this.mGoal.addError(acquireSolverVariable);
|
||
|
|
return acquireSolverVariable;
|
||
|
|
}
|
||
|
|
|
||
|
|
private SolverVariable acquireSolverVariable(SolverVariable.Type type, String str) {
|
||
|
|
SolverVariable acquire = this.mCache.solverVariablePool.acquire();
|
||
|
|
if (acquire == null) {
|
||
|
|
acquire = new SolverVariable(type, str);
|
||
|
|
acquire.setType(type, str);
|
||
|
|
} else {
|
||
|
|
acquire.reset();
|
||
|
|
acquire.setType(type, str);
|
||
|
|
}
|
||
|
|
int i = this.mPoolVariablesCount;
|
||
|
|
int i2 = POOL_SIZE;
|
||
|
|
if (i >= i2) {
|
||
|
|
int i3 = i2 * 2;
|
||
|
|
POOL_SIZE = i3;
|
||
|
|
this.mPoolVariables = (SolverVariable[]) Arrays.copyOf(this.mPoolVariables, i3);
|
||
|
|
}
|
||
|
|
SolverVariable[] solverVariableArr = this.mPoolVariables;
|
||
|
|
int i4 = this.mPoolVariablesCount;
|
||
|
|
this.mPoolVariablesCount = i4 + 1;
|
||
|
|
solverVariableArr[i4] = acquire;
|
||
|
|
return acquire;
|
||
|
|
}
|
||
|
|
|
||
|
|
ArrayRow getRow(int i) {
|
||
|
|
return this.mRows[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
float getValueFor(String str) {
|
||
|
|
SolverVariable variable = getVariable(str, SolverVariable.Type.UNRESTRICTED);
|
||
|
|
if (variable == null) {
|
||
|
|
return 0.0f;
|
||
|
|
}
|
||
|
|
return variable.computedValue;
|
||
|
|
}
|
||
|
|
|
||
|
|
public int getObjectVariableValue(Object obj) {
|
||
|
|
SolverVariable solverVariable = ((ConstraintAnchor) obj).getSolverVariable();
|
||
|
|
if (solverVariable != null) {
|
||
|
|
return (int) (solverVariable.computedValue + 0.5f);
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
SolverVariable getVariable(String str, SolverVariable.Type type) {
|
||
|
|
if (this.mVariables == null) {
|
||
|
|
this.mVariables = new HashMap<>();
|
||
|
|
}
|
||
|
|
SolverVariable solverVariable = this.mVariables.get(str);
|
||
|
|
return solverVariable == null ? createVariable(str, type) : solverVariable;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void minimize() throws Exception {
|
||
|
|
Metrics metrics = sMetrics;
|
||
|
|
if (metrics != null) {
|
||
|
|
metrics.minimize++;
|
||
|
|
}
|
||
|
|
if (this.graphOptimizer || this.newgraphOptimizer) {
|
||
|
|
Metrics metrics2 = sMetrics;
|
||
|
|
if (metrics2 != null) {
|
||
|
|
metrics2.graphOptimizer++;
|
||
|
|
}
|
||
|
|
for (int i = 0; i < this.mNumRows; i++) {
|
||
|
|
if (!this.mRows[i].isSimpleDefinition) {
|
||
|
|
minimizeGoal(this.mGoal);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Metrics metrics3 = sMetrics;
|
||
|
|
if (metrics3 != null) {
|
||
|
|
metrics3.fullySolved++;
|
||
|
|
}
|
||
|
|
computeValues();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
minimizeGoal(this.mGoal);
|
||
|
|
}
|
||
|
|
|
||
|
|
void minimizeGoal(Row row) throws Exception {
|
||
|
|
Metrics metrics = sMetrics;
|
||
|
|
if (metrics != null) {
|
||
|
|
metrics.minimizeGoal++;
|
||
|
|
Metrics metrics2 = sMetrics;
|
||
|
|
metrics2.maxVariables = Math.max(metrics2.maxVariables, this.mNumColumns);
|
||
|
|
Metrics metrics3 = sMetrics;
|
||
|
|
metrics3.maxRows = Math.max(metrics3.maxRows, this.mNumRows);
|
||
|
|
}
|
||
|
|
enforceBFS(row);
|
||
|
|
optimize(row, false);
|
||
|
|
computeValues();
|
||
|
|
}
|
||
|
|
|
||
|
|
final void cleanupRows() {
|
||
|
|
int i;
|
||
|
|
int i2 = 0;
|
||
|
|
while (i2 < this.mNumRows) {
|
||
|
|
ArrayRow arrayRow = this.mRows[i2];
|
||
|
|
if (arrayRow.variables.getCurrentSize() == 0) {
|
||
|
|
arrayRow.isSimpleDefinition = true;
|
||
|
|
}
|
||
|
|
if (arrayRow.isSimpleDefinition) {
|
||
|
|
arrayRow.variable.computedValue = arrayRow.constantValue;
|
||
|
|
arrayRow.variable.removeFromRow(arrayRow);
|
||
|
|
int i3 = i2;
|
||
|
|
while (true) {
|
||
|
|
i = this.mNumRows;
|
||
|
|
if (i3 >= i - 1) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
ArrayRow[] arrayRowArr = this.mRows;
|
||
|
|
int i4 = i3 + 1;
|
||
|
|
arrayRowArr[i3] = arrayRowArr[i4];
|
||
|
|
i3 = i4;
|
||
|
|
}
|
||
|
|
this.mRows[i - 1] = null;
|
||
|
|
this.mNumRows = i - 1;
|
||
|
|
i2--;
|
||
|
|
}
|
||
|
|
i2++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void addConstraint(ArrayRow arrayRow) {
|
||
|
|
SolverVariable pickPivot;
|
||
|
|
if (arrayRow == null) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
Metrics metrics = sMetrics;
|
||
|
|
if (metrics != null) {
|
||
|
|
metrics.constraints++;
|
||
|
|
if (arrayRow.isSimpleDefinition) {
|
||
|
|
sMetrics.simpleconstraints++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
boolean z = true;
|
||
|
|
if (this.mNumRows + 1 >= this.mMaxRows || this.mNumColumns + 1 >= this.mMaxColumns) {
|
||
|
|
increaseTableSize();
|
||
|
|
}
|
||
|
|
if (!arrayRow.isSimpleDefinition) {
|
||
|
|
arrayRow.updateFromSystem(this);
|
||
|
|
if (arrayRow.isEmpty()) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
arrayRow.ensurePositiveConstant();
|
||
|
|
if (arrayRow.chooseSubject(this)) {
|
||
|
|
SolverVariable createExtraVariable = createExtraVariable();
|
||
|
|
arrayRow.variable = createExtraVariable;
|
||
|
|
addRow(arrayRow);
|
||
|
|
this.mTempGoal.initFromRow(arrayRow);
|
||
|
|
optimize(this.mTempGoal, true);
|
||
|
|
if (createExtraVariable.definitionId == -1) {
|
||
|
|
if (arrayRow.variable == createExtraVariable && (pickPivot = arrayRow.pickPivot(createExtraVariable)) != null) {
|
||
|
|
Metrics metrics2 = sMetrics;
|
||
|
|
if (metrics2 != null) {
|
||
|
|
metrics2.pivots++;
|
||
|
|
}
|
||
|
|
arrayRow.pivot(pickPivot);
|
||
|
|
}
|
||
|
|
if (!arrayRow.isSimpleDefinition) {
|
||
|
|
arrayRow.variable.updateReferencesWithNewDefinition(arrayRow);
|
||
|
|
}
|
||
|
|
this.mNumRows--;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
z = false;
|
||
|
|
}
|
||
|
|
if (!arrayRow.hasKeyVariable() || z) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
addRow(arrayRow);
|
||
|
|
}
|
||
|
|
|
||
|
|
private final void addRow(ArrayRow arrayRow) {
|
||
|
|
if (OPTIMIZED_ENGINE) {
|
||
|
|
if (this.mRows[this.mNumRows] != null) {
|
||
|
|
this.mCache.optimizedArrayRowPool.release(this.mRows[this.mNumRows]);
|
||
|
|
}
|
||
|
|
} else if (this.mRows[this.mNumRows] != null) {
|
||
|
|
this.mCache.arrayRowPool.release(this.mRows[this.mNumRows]);
|
||
|
|
}
|
||
|
|
this.mRows[this.mNumRows] = arrayRow;
|
||
|
|
arrayRow.variable.definitionId = this.mNumRows;
|
||
|
|
this.mNumRows++;
|
||
|
|
arrayRow.variable.updateReferencesWithNewDefinition(arrayRow);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void removeRow(ArrayRow arrayRow) {
|
||
|
|
int i;
|
||
|
|
if (!arrayRow.isSimpleDefinition || arrayRow.variable == null) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (arrayRow.variable.definitionId != -1) {
|
||
|
|
int i2 = arrayRow.variable.definitionId;
|
||
|
|
while (true) {
|
||
|
|
i = this.mNumRows;
|
||
|
|
if (i2 >= i - 1) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
ArrayRow[] arrayRowArr = this.mRows;
|
||
|
|
int i3 = i2 + 1;
|
||
|
|
arrayRowArr[i2] = arrayRowArr[i3];
|
||
|
|
i2 = i3;
|
||
|
|
}
|
||
|
|
this.mNumRows = i - 1;
|
||
|
|
}
|
||
|
|
arrayRow.variable.setFinalValue(this, arrayRow.constantValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
private final int optimize(Row row, boolean z) {
|
||
|
|
Metrics metrics = sMetrics;
|
||
|
|
if (metrics != null) {
|
||
|
|
metrics.optimize++;
|
||
|
|
}
|
||
|
|
for (int i = 0; i < this.mNumColumns; i++) {
|
||
|
|
this.mAlreadyTestedCandidates[i] = false;
|
||
|
|
}
|
||
|
|
boolean z2 = false;
|
||
|
|
int i2 = 0;
|
||
|
|
while (!z2) {
|
||
|
|
Metrics metrics2 = sMetrics;
|
||
|
|
if (metrics2 != null) {
|
||
|
|
metrics2.iterations++;
|
||
|
|
}
|
||
|
|
i2++;
|
||
|
|
if (i2 >= this.mNumColumns * 2) {
|
||
|
|
return i2;
|
||
|
|
}
|
||
|
|
if (row.getKey() != null) {
|
||
|
|
this.mAlreadyTestedCandidates[row.getKey().id] = true;
|
||
|
|
}
|
||
|
|
SolverVariable pivotCandidate = row.getPivotCandidate(this, this.mAlreadyTestedCandidates);
|
||
|
|
if (pivotCandidate != null) {
|
||
|
|
if (this.mAlreadyTestedCandidates[pivotCandidate.id]) {
|
||
|
|
return i2;
|
||
|
|
}
|
||
|
|
this.mAlreadyTestedCandidates[pivotCandidate.id] = true;
|
||
|
|
}
|
||
|
|
if (pivotCandidate != null) {
|
||
|
|
float f = Float.MAX_VALUE;
|
||
|
|
int i3 = -1;
|
||
|
|
for (int i4 = 0; i4 < this.mNumRows; i4++) {
|
||
|
|
ArrayRow arrayRow = this.mRows[i4];
|
||
|
|
if (arrayRow.variable.mType != SolverVariable.Type.UNRESTRICTED && !arrayRow.isSimpleDefinition && arrayRow.hasVariable(pivotCandidate)) {
|
||
|
|
float f2 = arrayRow.variables.get(pivotCandidate);
|
||
|
|
if (f2 < 0.0f) {
|
||
|
|
float f3 = (-arrayRow.constantValue) / f2;
|
||
|
|
if (f3 < f) {
|
||
|
|
i3 = i4;
|
||
|
|
f = f3;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (i3 > -1) {
|
||
|
|
ArrayRow arrayRow2 = this.mRows[i3];
|
||
|
|
arrayRow2.variable.definitionId = -1;
|
||
|
|
Metrics metrics3 = sMetrics;
|
||
|
|
if (metrics3 != null) {
|
||
|
|
metrics3.pivots++;
|
||
|
|
}
|
||
|
|
arrayRow2.pivot(pivotCandidate);
|
||
|
|
arrayRow2.variable.definitionId = i3;
|
||
|
|
arrayRow2.variable.updateReferencesWithNewDefinition(arrayRow2);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
z2 = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return i2;
|
||
|
|
}
|
||
|
|
|
||
|
|
private int enforceBFS(Row row) throws Exception {
|
||
|
|
for (int i = 0; i < this.mNumRows; i++) {
|
||
|
|
if (this.mRows[i].variable.mType != SolverVariable.Type.UNRESTRICTED) {
|
||
|
|
float f = 0.0f;
|
||
|
|
if (this.mRows[i].constantValue < 0.0f) {
|
||
|
|
boolean z = false;
|
||
|
|
int i2 = 0;
|
||
|
|
while (!z) {
|
||
|
|
Metrics metrics = sMetrics;
|
||
|
|
if (metrics != null) {
|
||
|
|
metrics.bfs++;
|
||
|
|
}
|
||
|
|
i2++;
|
||
|
|
float f2 = Float.MAX_VALUE;
|
||
|
|
int i3 = -1;
|
||
|
|
int i4 = -1;
|
||
|
|
int i5 = 0;
|
||
|
|
int i6 = 0;
|
||
|
|
while (true) {
|
||
|
|
int i7 = 1;
|
||
|
|
if (i5 >= this.mNumRows) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
ArrayRow arrayRow = this.mRows[i5];
|
||
|
|
if (arrayRow.variable.mType != SolverVariable.Type.UNRESTRICTED && !arrayRow.isSimpleDefinition && arrayRow.constantValue < f) {
|
||
|
|
while (i7 < this.mNumColumns) {
|
||
|
|
SolverVariable solverVariable = this.mCache.mIndexedVariables[i7];
|
||
|
|
float f3 = arrayRow.variables.get(solverVariable);
|
||
|
|
if (f3 > f) {
|
||
|
|
for (int i8 = 0; i8 < 9; i8++) {
|
||
|
|
float f4 = solverVariable.strengthVector[i8] / f3;
|
||
|
|
if ((f4 < f2 && i8 == i6) || i8 > i6) {
|
||
|
|
i6 = i8;
|
||
|
|
f2 = f4;
|
||
|
|
i3 = i5;
|
||
|
|
i4 = i7;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
i7++;
|
||
|
|
f = 0.0f;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
i5++;
|
||
|
|
f = 0.0f;
|
||
|
|
}
|
||
|
|
if (i3 != -1) {
|
||
|
|
ArrayRow arrayRow2 = this.mRows[i3];
|
||
|
|
arrayRow2.variable.definitionId = -1;
|
||
|
|
Metrics metrics2 = sMetrics;
|
||
|
|
if (metrics2 != null) {
|
||
|
|
metrics2.pivots++;
|
||
|
|
}
|
||
|
|
arrayRow2.pivot(this.mCache.mIndexedVariables[i4]);
|
||
|
|
arrayRow2.variable.definitionId = i3;
|
||
|
|
arrayRow2.variable.updateReferencesWithNewDefinition(arrayRow2);
|
||
|
|
} else {
|
||
|
|
z = true;
|
||
|
|
}
|
||
|
|
if (i2 > this.mNumColumns / 2) {
|
||
|
|
z = true;
|
||
|
|
}
|
||
|
|
f = 0.0f;
|
||
|
|
}
|
||
|
|
return i2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void computeValues() {
|
||
|
|
for (int i = 0; i < this.mNumRows; i++) {
|
||
|
|
ArrayRow arrayRow = this.mRows[i];
|
||
|
|
arrayRow.variable.computedValue = arrayRow.constantValue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void displayRows() {
|
||
|
|
displaySolverVariables();
|
||
|
|
String str = "";
|
||
|
|
for (int i = 0; i < this.mNumRows; i++) {
|
||
|
|
str = (str + this.mRows[i]) + "\n";
|
||
|
|
}
|
||
|
|
System.out.println(str + this.mGoal + "\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
public void displayReadableRows() {
|
||
|
|
displaySolverVariables();
|
||
|
|
String str = "";
|
||
|
|
for (int i = 0; i < this.mVariablesID; i++) {
|
||
|
|
SolverVariable solverVariable = this.mCache.mIndexedVariables[i];
|
||
|
|
if (solverVariable != null && solverVariable.isFinalValue) {
|
||
|
|
str = str + " $[" + i + "] => " + solverVariable + " = " + solverVariable.computedValue + "\n";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
String str2 = str + "\n\n # ";
|
||
|
|
for (int i2 = 0; i2 < this.mNumRows; i2++) {
|
||
|
|
str2 = (str2 + this.mRows[i2].toReadableString()) + "\n # ";
|
||
|
|
}
|
||
|
|
if (this.mGoal != null) {
|
||
|
|
str2 = str2 + "Goal: " + this.mGoal + "\n";
|
||
|
|
}
|
||
|
|
System.out.println(str2);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void displayVariablesReadableRows() {
|
||
|
|
displaySolverVariables();
|
||
|
|
String str = "";
|
||
|
|
for (int i = 0; i < this.mNumRows; i++) {
|
||
|
|
if (this.mRows[i].variable.mType == SolverVariable.Type.UNRESTRICTED) {
|
||
|
|
str = (str + this.mRows[i].toReadableString()) + "\n";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
System.out.println(str + this.mGoal + "\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
public int getMemoryUsed() {
|
||
|
|
int i = 0;
|
||
|
|
for (int i2 = 0; i2 < this.mNumRows; i2++) {
|
||
|
|
ArrayRow arrayRow = this.mRows[i2];
|
||
|
|
if (arrayRow != null) {
|
||
|
|
i += arrayRow.sizeInBytes();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
|
||
|
|
void displaySystemInformations() {
|
||
|
|
int i = 0;
|
||
|
|
for (int i2 = 0; i2 < this.TABLE_SIZE; i2++) {
|
||
|
|
ArrayRow arrayRow = this.mRows[i2];
|
||
|
|
if (arrayRow != null) {
|
||
|
|
i += arrayRow.sizeInBytes();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
int i3 = 0;
|
||
|
|
for (int i4 = 0; i4 < this.mNumRows; i4++) {
|
||
|
|
ArrayRow arrayRow2 = this.mRows[i4];
|
||
|
|
if (arrayRow2 != null) {
|
||
|
|
i3 += arrayRow2.sizeInBytes();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
PrintStream printStream = System.out;
|
||
|
|
StringBuilder append = new StringBuilder("Linear System -> Table size: ").append(this.TABLE_SIZE).append(" (");
|
||
|
|
int i5 = this.TABLE_SIZE;
|
||
|
|
printStream.println(append.append(getDisplaySize(i5 * i5)).append(") -- row sizes: ").append(getDisplaySize(i)).append(", actual size: ").append(getDisplaySize(i3)).append(" rows: ").append(this.mNumRows).append("/").append(this.mMaxRows).append(" cols: ").append(this.mNumColumns).append("/").append(this.mMaxColumns).append(" 0 occupied cells, ").append(getDisplaySize(0)).toString());
|
||
|
|
}
|
||
|
|
|
||
|
|
private void displaySolverVariables() {
|
||
|
|
System.out.println("Display Rows (" + this.mNumRows + ViewHierarchyNode.JsonKeys.X + this.mNumColumns + ")\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
private String getDisplaySize(int i) {
|
||
|
|
int i2 = i * 4;
|
||
|
|
int i3 = i2 / 1024;
|
||
|
|
int i4 = i3 / 1024;
|
||
|
|
if (i4 > 0) {
|
||
|
|
return "" + i4 + " Mb";
|
||
|
|
}
|
||
|
|
if (i3 > 0) {
|
||
|
|
return "" + i3 + " Kb";
|
||
|
|
}
|
||
|
|
return "" + i2 + " bytes";
|
||
|
|
}
|
||
|
|
|
||
|
|
public void addGreaterThan(SolverVariable solverVariable, SolverVariable solverVariable2, int i, int i2) {
|
||
|
|
ArrayRow createRow = createRow();
|
||
|
|
SolverVariable createSlackVariable = createSlackVariable();
|
||
|
|
createSlackVariable.strength = 0;
|
||
|
|
createRow.createRowGreaterThan(solverVariable, solverVariable2, createSlackVariable, i);
|
||
|
|
if (i2 != 8) {
|
||
|
|
addSingleError(createRow, (int) (createRow.variables.get(createSlackVariable) * (-1.0f)), i2);
|
||
|
|
}
|
||
|
|
addConstraint(createRow);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void addGreaterBarrier(SolverVariable solverVariable, SolverVariable solverVariable2, int i, boolean z) {
|
||
|
|
ArrayRow createRow = createRow();
|
||
|
|
SolverVariable createSlackVariable = createSlackVariable();
|
||
|
|
createSlackVariable.strength = 0;
|
||
|
|
createRow.createRowGreaterThan(solverVariable, solverVariable2, createSlackVariable, i);
|
||
|
|
addConstraint(createRow);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void addLowerThan(SolverVariable solverVariable, SolverVariable solverVariable2, int i, int i2) {
|
||
|
|
ArrayRow createRow = createRow();
|
||
|
|
SolverVariable createSlackVariable = createSlackVariable();
|
||
|
|
createSlackVariable.strength = 0;
|
||
|
|
createRow.createRowLowerThan(solverVariable, solverVariable2, createSlackVariable, i);
|
||
|
|
if (i2 != 8) {
|
||
|
|
addSingleError(createRow, (int) (createRow.variables.get(createSlackVariable) * (-1.0f)), i2);
|
||
|
|
}
|
||
|
|
addConstraint(createRow);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void addLowerBarrier(SolverVariable solverVariable, SolverVariable solverVariable2, int i, boolean z) {
|
||
|
|
ArrayRow createRow = createRow();
|
||
|
|
SolverVariable createSlackVariable = createSlackVariable();
|
||
|
|
createSlackVariable.strength = 0;
|
||
|
|
createRow.createRowLowerThan(solverVariable, solverVariable2, createSlackVariable, i);
|
||
|
|
addConstraint(createRow);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void addCentering(SolverVariable solverVariable, SolverVariable solverVariable2, int i, float f, SolverVariable solverVariable3, SolverVariable solverVariable4, int i2, int i3) {
|
||
|
|
ArrayRow createRow = createRow();
|
||
|
|
createRow.createRowCentering(solverVariable, solverVariable2, i, f, solverVariable3, solverVariable4, i2);
|
||
|
|
if (i3 != 8) {
|
||
|
|
createRow.addError(this, i3);
|
||
|
|
}
|
||
|
|
addConstraint(createRow);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void addRatio(SolverVariable solverVariable, SolverVariable solverVariable2, SolverVariable solverVariable3, SolverVariable solverVariable4, float f, int i) {
|
||
|
|
ArrayRow createRow = createRow();
|
||
|
|
createRow.createRowDimensionRatio(solverVariable, solverVariable2, solverVariable3, solverVariable4, f);
|
||
|
|
if (i != 8) {
|
||
|
|
createRow.addError(this, i);
|
||
|
|
}
|
||
|
|
addConstraint(createRow);
|
||
|
|
}
|
||
|
|
|
||
|
|
public ArrayRow addEquality(SolverVariable solverVariable, SolverVariable solverVariable2, int i, int i2) {
|
||
|
|
if (i2 == 8 && solverVariable2.isFinalValue && solverVariable.definitionId == -1) {
|
||
|
|
solverVariable.setFinalValue(this, solverVariable2.computedValue + i);
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
ArrayRow createRow = createRow();
|
||
|
|
createRow.createRowEquals(solverVariable, solverVariable2, i);
|
||
|
|
if (i2 != 8) {
|
||
|
|
createRow.addError(this, i2);
|
||
|
|
}
|
||
|
|
addConstraint(createRow);
|
||
|
|
return createRow;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void addEquality(SolverVariable solverVariable, int i) {
|
||
|
|
if (solverVariable.definitionId == -1) {
|
||
|
|
solverVariable.setFinalValue(this, i);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
int i2 = solverVariable.definitionId;
|
||
|
|
if (solverVariable.definitionId != -1) {
|
||
|
|
ArrayRow arrayRow = this.mRows[i2];
|
||
|
|
if (arrayRow.isSimpleDefinition) {
|
||
|
|
arrayRow.constantValue = i;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (arrayRow.variables.getCurrentSize() == 0) {
|
||
|
|
arrayRow.isSimpleDefinition = true;
|
||
|
|
arrayRow.constantValue = i;
|
||
|
|
return;
|
||
|
|
} else {
|
||
|
|
ArrayRow createRow = createRow();
|
||
|
|
createRow.createRowEquals(solverVariable, i);
|
||
|
|
addConstraint(createRow);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ArrayRow createRow2 = createRow();
|
||
|
|
createRow2.createRowDefinition(solverVariable, i);
|
||
|
|
addConstraint(createRow2);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static ArrayRow createRowDimensionPercent(LinearSystem linearSystem, SolverVariable solverVariable, SolverVariable solverVariable2, float f) {
|
||
|
|
return linearSystem.createRow().createRowDimensionPercent(solverVariable, solverVariable2, f);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void addCenterPoint(ConstraintWidget constraintWidget, ConstraintWidget constraintWidget2, float f, int i) {
|
||
|
|
SolverVariable createObjectVariable = createObjectVariable(constraintWidget.getAnchor(ConstraintAnchor.Type.LEFT));
|
||
|
|
SolverVariable createObjectVariable2 = createObjectVariable(constraintWidget.getAnchor(ConstraintAnchor.Type.TOP));
|
||
|
|
SolverVariable createObjectVariable3 = createObjectVariable(constraintWidget.getAnchor(ConstraintAnchor.Type.RIGHT));
|
||
|
|
SolverVariable createObjectVariable4 = createObjectVariable(constraintWidget.getAnchor(ConstraintAnchor.Type.BOTTOM));
|
||
|
|
SolverVariable createObjectVariable5 = createObjectVariable(constraintWidget2.getAnchor(ConstraintAnchor.Type.LEFT));
|
||
|
|
SolverVariable createObjectVariable6 = createObjectVariable(constraintWidget2.getAnchor(ConstraintAnchor.Type.TOP));
|
||
|
|
SolverVariable createObjectVariable7 = createObjectVariable(constraintWidget2.getAnchor(ConstraintAnchor.Type.RIGHT));
|
||
|
|
SolverVariable createObjectVariable8 = createObjectVariable(constraintWidget2.getAnchor(ConstraintAnchor.Type.BOTTOM));
|
||
|
|
ArrayRow createRow = createRow();
|
||
|
|
double d = f;
|
||
|
|
double d2 = i;
|
||
|
|
createRow.createRowWithAngle(createObjectVariable2, createObjectVariable4, createObjectVariable6, createObjectVariable8, (float) (Math.sin(d) * d2));
|
||
|
|
addConstraint(createRow);
|
||
|
|
ArrayRow createRow2 = createRow();
|
||
|
|
createRow2.createRowWithAngle(createObjectVariable, createObjectVariable3, createObjectVariable5, createObjectVariable7, (float) (Math.cos(d) * d2));
|
||
|
|
addConstraint(createRow2);
|
||
|
|
}
|
||
|
|
}
|