da12ac8646
* refactor avghelper * #59 backend Co-authored-by: DarK-rtfm <44683230+DarK-rtfm@users.noreply.github.com>
118 lines
3.1 KiB
Dart
118 lines
3.1 KiB
Dart
/*
|
|
* Maintainer: DarK
|
|
* Translated from C version
|
|
* ##Please do NOT modify if you don't know whats going on##
|
|
*
|
|
* Issue: #59
|
|
*
|
|
* Future changes / ideas:
|
|
* - `best` should be configurable
|
|
*/
|
|
import 'dart:math';
|
|
|
|
import 'package:filcnaplo/helpers/average_helper.dart';
|
|
import 'package:filcnaplo_kreta_api/models/grade.dart';
|
|
|
|
/// Generate list of grades that achieve the wanted goal.
|
|
/// After generating possible options, it (when doing so would NOT result in empty list) filters with two criteria:
|
|
/// - Plan should not contain more than 15 grades
|
|
/// - Plan should not contain only one type of grade
|
|
///
|
|
/// **Usage**:
|
|
///
|
|
/// ```dart
|
|
/// List<int> GoalPlanner(double goal, List<Grade> grades).solve().plan
|
|
/// ```
|
|
class GoalPlanner {
|
|
final double goal;
|
|
final List<Grade> grades;
|
|
List<Plan> plans = [];
|
|
GoalPlanner(this.goal, this.grades);
|
|
|
|
bool _allowed(int grade) => grade > goal;
|
|
|
|
Avg _addToAvg(Avg base, int grade, int n) => Avg((base.avg * base.n + grade * n) / (base.n + n), base.n + n);
|
|
List<T> _addToList<T>(List<T> l, T e, int n) {
|
|
if (n == 0) return l;
|
|
List<T> tmp = l;
|
|
for (int i = 0; i < n; i++) tmp.add(e);
|
|
return tmp;
|
|
}
|
|
|
|
void _generate(Generator g) {
|
|
// Exit condition 1: Generator has working plan.
|
|
if (g.currentAvg.avg >= goal) {
|
|
plans.add(Plan(g.plan));
|
|
return;
|
|
}
|
|
// Exit condition 2: Generator plan will never work.
|
|
if (!_allowed(g.gradeToAdd)) return;
|
|
for (int i = 0; i < g.max; i++) {
|
|
int newGradeToAdd = g.gradeToAdd - 1;
|
|
List<int> newPlan = _addToList<int>(g.plan, g.gradeToAdd, i);
|
|
Avg newAvg = _addToAvg(g.currentAvg, g.gradeToAdd, i);
|
|
int newN = AverageHelper.howManyNeeded(newGradeToAdd, [], goal);
|
|
|
|
_generate(Generator(newGradeToAdd, newN, newAvg, newPlan));
|
|
}
|
|
}
|
|
|
|
Plan solve() {
|
|
_generate(
|
|
Generator(
|
|
5,
|
|
AverageHelper.howManyNeeded(
|
|
5,
|
|
[],
|
|
goal,
|
|
filcgrade: false,
|
|
avg: AverageHelper.averageEvals(grades),
|
|
wsum: AverageHelper.weightSum(grades),
|
|
),
|
|
Avg(AverageHelper.averageEvals(grades), AverageHelper.weightSum(grades)),
|
|
[],
|
|
),
|
|
);
|
|
|
|
// Calculate Statistics
|
|
plans.forEach((e) {
|
|
e.sum = e.plan.fold(0, (int a, b) => a + b);
|
|
e.avg = e.sum / e.plan.length;
|
|
e.sigma = sqrt(e.plan.map((i) => pow(i - e.avg, 2)).fold(0, (num a, b) => a + b) / e.plan.length);
|
|
});
|
|
|
|
// filter without aggression
|
|
if (plans.where((e) => e.plan.length < 15).isNotEmpty) plans.removeWhere((e) => !(e.plan.length < 15));
|
|
if (plans.where((e) => e.sigma > 1).isNotEmpty) plans.removeWhere((e) => !(e.sigma > 1));
|
|
|
|
return plans[Random().nextInt(plans.length)];
|
|
}
|
|
}
|
|
|
|
class Avg {
|
|
final double avg;
|
|
final double n;
|
|
|
|
Avg(this.avg, this.n);
|
|
}
|
|
|
|
class Generator {
|
|
final int gradeToAdd;
|
|
final int max;
|
|
final Avg currentAvg;
|
|
final List<int> plan;
|
|
|
|
Generator(this.gradeToAdd, this.max, this.currentAvg, this.plan);
|
|
}
|
|
|
|
class Plan {
|
|
final List<int> plan;
|
|
int sum = 0;
|
|
double avg = 0;
|
|
int med = 0; // currently
|
|
int mod = 0; // unused
|
|
double sigma = 0;
|
|
|
|
Plan(this.plan);
|
|
}
|