2021-07-24 02:37:17 +00:00
|
|
|
package androidx.constraintlayout.solver;
|
|
|
|
|
|
|
|
import androidx.constraintlayout.solver.ArrayRow;
|
|
|
|
import c.d.b.a.a;
|
|
|
|
import java.util.Arrays;
|
|
|
|
import java.util.Comparator;
|
|
|
|
public class PriorityGoalRow extends ArrayRow {
|
|
|
|
private static final boolean DEBUG = false;
|
|
|
|
public static final int NOT_FOUND = -1;
|
|
|
|
private static final float epsilon = 1.0E-4f;
|
|
|
|
private int TABLE_SIZE = 128;
|
|
|
|
public GoalVariableAccessor accessor = new GoalVariableAccessor(this);
|
|
|
|
private SolverVariable[] arrayGoals = new SolverVariable[128];
|
|
|
|
public Cache mCache;
|
|
|
|
private int numGoals = 0;
|
|
|
|
private SolverVariable[] sortArray = new SolverVariable[128];
|
|
|
|
|
|
|
|
/* renamed from: androidx.constraintlayout.solver.PriorityGoalRow$1 reason: invalid class name */
|
|
|
|
public class AnonymousClass1 implements Comparator<SolverVariable> {
|
|
|
|
public AnonymousClass1() {
|
|
|
|
}
|
|
|
|
|
|
|
|
public int compare(SolverVariable solverVariable, SolverVariable solverVariable2) {
|
2021-11-02 06:38:17 +00:00
|
|
|
return solverVariable.f23id - solverVariable2.f23id;
|
2021-07-24 02:37:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public class GoalVariableAccessor implements Comparable {
|
|
|
|
public PriorityGoalRow row;
|
|
|
|
public SolverVariable variable;
|
|
|
|
|
|
|
|
public GoalVariableAccessor(PriorityGoalRow priorityGoalRow) {
|
|
|
|
this.row = priorityGoalRow;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void add(SolverVariable solverVariable) {
|
|
|
|
for (int i = 0; i < 9; i++) {
|
|
|
|
float[] fArr = this.variable.goalStrengthVector;
|
|
|
|
fArr[i] = fArr[i] + solverVariable.goalStrengthVector[i];
|
|
|
|
if (Math.abs(fArr[i]) < 1.0E-4f) {
|
|
|
|
this.variable.goalStrengthVector[i] = 0.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean addToGoal(SolverVariable solverVariable, float f) {
|
|
|
|
boolean z2 = true;
|
|
|
|
if (this.variable.inGoal) {
|
|
|
|
for (int i = 0; i < 9; i++) {
|
|
|
|
float[] fArr = this.variable.goalStrengthVector;
|
|
|
|
fArr[i] = (solverVariable.goalStrengthVector[i] * f) + fArr[i];
|
|
|
|
if (Math.abs(fArr[i]) < 1.0E-4f) {
|
|
|
|
this.variable.goalStrengthVector[i] = 0.0f;
|
|
|
|
} else {
|
|
|
|
z2 = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (z2) {
|
|
|
|
PriorityGoalRow.access$000(PriorityGoalRow.this, this.variable);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
for (int i2 = 0; i2 < 9; i2++) {
|
|
|
|
float f2 = solverVariable.goalStrengthVector[i2];
|
|
|
|
if (f2 != 0.0f) {
|
|
|
|
float f3 = f2 * f;
|
|
|
|
if (Math.abs(f3) < 1.0E-4f) {
|
|
|
|
f3 = 0.0f;
|
|
|
|
}
|
|
|
|
this.variable.goalStrengthVector[i2] = f3;
|
|
|
|
} else {
|
|
|
|
this.variable.goalStrengthVector[i2] = 0.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override // java.lang.Comparable
|
|
|
|
public int compareTo(Object obj) {
|
2021-11-02 06:38:17 +00:00
|
|
|
return this.variable.f23id - ((SolverVariable) obj).f23id;
|
2021-07-24 02:37:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public void init(SolverVariable solverVariable) {
|
|
|
|
this.variable = solverVariable;
|
|
|
|
}
|
|
|
|
|
|
|
|
public final boolean isNegative() {
|
|
|
|
for (int i = 8; i >= 0; i--) {
|
|
|
|
float f = this.variable.goalStrengthVector[i];
|
|
|
|
if (f > 0.0f) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (f < 0.0f) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
public final boolean isNull() {
|
|
|
|
for (int i = 0; i < 9; i++) {
|
|
|
|
if (this.variable.goalStrengthVector[i] != 0.0f) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
public final boolean isSmallerThan(SolverVariable solverVariable) {
|
|
|
|
int i = 8;
|
|
|
|
while (true) {
|
|
|
|
if (i < 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
float f = solverVariable.goalStrengthVector[i];
|
|
|
|
float f2 = this.variable.goalStrengthVector[i];
|
|
|
|
if (f2 == f) {
|
|
|
|
i--;
|
|
|
|
} else if (f2 < f) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void reset() {
|
|
|
|
Arrays.fill(this.variable.goalStrengthVector, 0.0f);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override // java.lang.Object
|
|
|
|
public String toString() {
|
|
|
|
String str = "[ ";
|
|
|
|
if (this.variable != null) {
|
|
|
|
for (int i = 0; i < 9; i++) {
|
2021-10-09 06:29:02 +00:00
|
|
|
StringBuilder O = a.O(str);
|
|
|
|
O.append(this.variable.goalStrengthVector[i]);
|
|
|
|
O.append(" ");
|
|
|
|
str = O.toString();
|
2021-07-24 02:37:17 +00:00
|
|
|
}
|
|
|
|
}
|
2021-10-09 06:29:02 +00:00
|
|
|
StringBuilder S = a.S(str, "] ");
|
|
|
|
S.append(this.variable);
|
|
|
|
return S.toString();
|
2021-07-24 02:37:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public PriorityGoalRow(Cache cache) {
|
|
|
|
super(cache);
|
|
|
|
this.mCache = cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static /* synthetic */ void access$000(PriorityGoalRow priorityGoalRow, SolverVariable solverVariable) {
|
|
|
|
priorityGoalRow.removeGoal(solverVariable);
|
|
|
|
}
|
|
|
|
|
|
|
|
private final void addToGoal(SolverVariable solverVariable) {
|
|
|
|
int i;
|
|
|
|
int i2 = this.numGoals + 1;
|
|
|
|
SolverVariable[] solverVariableArr = this.arrayGoals;
|
|
|
|
if (i2 > solverVariableArr.length) {
|
|
|
|
SolverVariable[] solverVariableArr2 = (SolverVariable[]) Arrays.copyOf(solverVariableArr, solverVariableArr.length * 2);
|
|
|
|
this.arrayGoals = solverVariableArr2;
|
|
|
|
this.sortArray = (SolverVariable[]) Arrays.copyOf(solverVariableArr2, solverVariableArr2.length * 2);
|
|
|
|
}
|
|
|
|
SolverVariable[] solverVariableArr3 = this.arrayGoals;
|
|
|
|
int i3 = this.numGoals;
|
|
|
|
solverVariableArr3[i3] = solverVariable;
|
|
|
|
int i4 = i3 + 1;
|
|
|
|
this.numGoals = i4;
|
2021-11-02 06:38:17 +00:00
|
|
|
if (i4 > 1 && solverVariableArr3[i4 - 1].f23id > solverVariable.f23id) {
|
2021-07-24 02:37:17 +00:00
|
|
|
int i5 = 0;
|
|
|
|
while (true) {
|
|
|
|
i = this.numGoals;
|
|
|
|
if (i5 >= i) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
this.sortArray[i5] = this.arrayGoals[i5];
|
|
|
|
i5++;
|
|
|
|
}
|
|
|
|
Arrays.sort(this.sortArray, 0, i, new AnonymousClass1());
|
|
|
|
for (int i6 = 0; i6 < this.numGoals; i6++) {
|
|
|
|
this.arrayGoals[i6] = this.sortArray[i6];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
solverVariable.inGoal = true;
|
|
|
|
solverVariable.addToRow(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
private final void removeGoal(SolverVariable solverVariable) {
|
|
|
|
int i = 0;
|
|
|
|
while (i < this.numGoals) {
|
|
|
|
if (this.arrayGoals[i] == solverVariable) {
|
|
|
|
while (true) {
|
|
|
|
int i2 = this.numGoals;
|
|
|
|
if (i < i2 - 1) {
|
|
|
|
SolverVariable[] solverVariableArr = this.arrayGoals;
|
|
|
|
int i3 = i + 1;
|
|
|
|
solverVariableArr[i] = solverVariableArr[i3];
|
|
|
|
i = i3;
|
|
|
|
} else {
|
|
|
|
this.numGoals = i2 - 1;
|
|
|
|
solverVariable.inGoal = false;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override // androidx.constraintlayout.solver.ArrayRow, androidx.constraintlayout.solver.LinearSystem.Row
|
|
|
|
public void addError(SolverVariable solverVariable) {
|
|
|
|
this.accessor.init(solverVariable);
|
|
|
|
this.accessor.reset();
|
|
|
|
solverVariable.goalStrengthVector[solverVariable.strength] = 1.0f;
|
|
|
|
addToGoal(solverVariable);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override // androidx.constraintlayout.solver.ArrayRow, androidx.constraintlayout.solver.LinearSystem.Row
|
|
|
|
public void clear() {
|
|
|
|
this.numGoals = 0;
|
|
|
|
this.constantValue = 0.0f;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override // androidx.constraintlayout.solver.ArrayRow, androidx.constraintlayout.solver.LinearSystem.Row
|
|
|
|
public SolverVariable getPivotCandidate(LinearSystem linearSystem, boolean[] zArr) {
|
|
|
|
int i = -1;
|
|
|
|
for (int i2 = 0; i2 < this.numGoals; i2++) {
|
|
|
|
SolverVariable solverVariable = this.arrayGoals[i2];
|
2021-11-02 06:38:17 +00:00
|
|
|
if (!zArr[solverVariable.f23id]) {
|
2021-07-24 02:37:17 +00:00
|
|
|
this.accessor.init(solverVariable);
|
|
|
|
if (i == -1) {
|
|
|
|
if (!this.accessor.isNegative()) {
|
|
|
|
}
|
|
|
|
} else if (!this.accessor.isSmallerThan(this.arrayGoals[i])) {
|
|
|
|
}
|
|
|
|
i = i2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (i == -1) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
return this.arrayGoals[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override // androidx.constraintlayout.solver.ArrayRow, androidx.constraintlayout.solver.LinearSystem.Row
|
|
|
|
public boolean isEmpty() {
|
|
|
|
return this.numGoals == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override // androidx.constraintlayout.solver.ArrayRow
|
|
|
|
public String toString() {
|
2021-10-09 06:29:02 +00:00
|
|
|
StringBuilder S = a.S("", " goal -> (");
|
|
|
|
S.append(this.constantValue);
|
|
|
|
S.append(") : ");
|
|
|
|
String sb = S.toString();
|
2021-07-24 02:37:17 +00:00
|
|
|
for (int i = 0; i < this.numGoals; i++) {
|
|
|
|
this.accessor.init(this.arrayGoals[i]);
|
|
|
|
sb = sb + this.accessor + " ";
|
|
|
|
}
|
|
|
|
return sb;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override // androidx.constraintlayout.solver.ArrayRow, androidx.constraintlayout.solver.LinearSystem.Row
|
|
|
|
public void updateFromRow(LinearSystem linearSystem, ArrayRow arrayRow, boolean z2) {
|
|
|
|
SolverVariable solverVariable = arrayRow.variable;
|
|
|
|
if (solverVariable != null) {
|
|
|
|
ArrayRow.ArrayRowVariables arrayRowVariables = arrayRow.variables;
|
|
|
|
int currentSize = arrayRowVariables.getCurrentSize();
|
|
|
|
for (int i = 0; i < currentSize; i++) {
|
|
|
|
SolverVariable variable = arrayRowVariables.getVariable(i);
|
|
|
|
float variableValue = arrayRowVariables.getVariableValue(i);
|
|
|
|
this.accessor.init(variable);
|
|
|
|
if (this.accessor.addToGoal(solverVariable, variableValue)) {
|
|
|
|
addToGoal(variable);
|
|
|
|
}
|
|
|
|
this.constantValue = (arrayRow.constantValue * variableValue) + this.constantValue;
|
|
|
|
}
|
|
|
|
removeGoal(solverVariable);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|