feat: score single, multiple and self-check answers with configurable partial credit and penalty
This commit is contained in:
174
classes/scoring.go
Normal file
174
classes/scoring.go
Normal file
@@ -0,0 +1,174 @@
|
||||
package classes
|
||||
|
||||
import (
|
||||
"math"
|
||||
"strconv"
|
||||
|
||||
"git.golem15.com/golem15/sm-quizzes-plugin/models"
|
||||
"git.golem15.com/golem15/summercms/modules/compass"
|
||||
)
|
||||
|
||||
// ScoringConfig holds the golem15.quizzes.scoring.* settings.
|
||||
type ScoringConfig struct {
|
||||
// MultiplePartial gives partial credit on a multiple question: (correct
|
||||
// chosen - wrong chosen) / correct answers, floored at 0.
|
||||
MultiplePartial bool
|
||||
// PenaltyWrong is the fraction of a question's points subtracted for a
|
||||
// wrong answer, from 0 (no penalty) to 1.
|
||||
PenaltyWrong float64
|
||||
}
|
||||
|
||||
// ScoringConfigFrom reads golem15.quizzes.scoring.multiple_partial and
|
||||
// golem15.quizzes.scoring.penalty_wrong. A missing config gives the defaults
|
||||
// (no partial credit, no penalty); the penalty is clamped to [0, 1].
|
||||
func ScoringConfigFrom(cfg *compass.Config) ScoringConfig {
|
||||
if cfg == nil {
|
||||
return ScoringConfig{}
|
||||
}
|
||||
out := ScoringConfig{MultiplePartial: cfg.Bool("golem15.quizzes.scoring.multiple_partial")}
|
||||
if v, ok := cfg.Lookup("golem15.quizzes.scoring.penalty_wrong"); ok {
|
||||
out.PenaltyWrong = toFloat(v)
|
||||
}
|
||||
out.PenaltyWrong = math.Min(math.Max(out.PenaltyWrong, 0), 1)
|
||||
return out
|
||||
}
|
||||
|
||||
func toFloat(v any) float64 {
|
||||
switch n := v.(type) {
|
||||
case float64:
|
||||
return n
|
||||
case float32:
|
||||
return float64(n)
|
||||
case int:
|
||||
return float64(n)
|
||||
case int64:
|
||||
return float64(n)
|
||||
case uint64:
|
||||
return float64(n)
|
||||
case string:
|
||||
f, err := strconv.ParseFloat(n, 64)
|
||||
if err == nil {
|
||||
return f
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// ScoreInput is one answered question, as the scorer sees it.
|
||||
type ScoreInput struct {
|
||||
// Type is models.TypeSingle, models.TypeMultiple or models.TypeSelfCheck.
|
||||
Type string
|
||||
// Points is the question's full value.
|
||||
Points int
|
||||
// CorrectIDs are the IDs of the question's correct answers.
|
||||
CorrectIDs []uint
|
||||
// ChosenIDs are the answer IDs the user chose (single and multiple).
|
||||
ChosenIDs []uint
|
||||
// Known is the user's own mark on a self_check question.
|
||||
Known *bool
|
||||
}
|
||||
|
||||
// ScoreResult is the outcome of one question.
|
||||
type ScoreResult struct {
|
||||
// IsCorrect is true only for a fully correct answer.
|
||||
IsCorrect bool
|
||||
// Points earned; negative when a penalty applies. Totals are floored at
|
||||
// 0 by Totals, never per question.
|
||||
Points float64
|
||||
}
|
||||
|
||||
// Score grades one answer. It is a pure function:
|
||||
//
|
||||
// - single: correct when exactly one answer is chosen and it is a correct
|
||||
// one.
|
||||
// - multiple: correct when the chosen set equals the correct set. With
|
||||
// MultiplePartial a partly right answer earns (correct chosen - wrong
|
||||
// chosen) / correct answers of the points, floored at 0.
|
||||
// - self_check: correct when the user marked it as known.
|
||||
//
|
||||
// An answer that earns nothing and is not empty is wrong: with PenaltyWrong
|
||||
// it loses that fraction of the question's points. An empty answer and a
|
||||
// self_check marked as unknown are never penalised.
|
||||
func Score(in ScoreInput, cfg ScoringConfig) ScoreResult {
|
||||
full := float64(max(in.Points, 0))
|
||||
switch in.Type {
|
||||
case models.TypeSelfCheck:
|
||||
if in.Known != nil && *in.Known {
|
||||
return ScoreResult{IsCorrect: true, Points: full}
|
||||
}
|
||||
return ScoreResult{}
|
||||
case models.TypeSingle, models.TypeMultiple:
|
||||
default:
|
||||
return ScoreResult{}
|
||||
}
|
||||
|
||||
chosen := uniqueIDs(in.ChosenIDs)
|
||||
if len(chosen) == 0 {
|
||||
return ScoreResult{}
|
||||
}
|
||||
correct := make(map[uint]bool, len(in.CorrectIDs))
|
||||
for _, id := range in.CorrectIDs {
|
||||
correct[id] = true
|
||||
}
|
||||
right, wrong := 0, 0
|
||||
for _, id := range chosen {
|
||||
if correct[id] {
|
||||
right++
|
||||
} else {
|
||||
wrong++
|
||||
}
|
||||
}
|
||||
|
||||
var res ScoreResult
|
||||
switch in.Type {
|
||||
case models.TypeSingle:
|
||||
if len(chosen) == 1 && right == 1 {
|
||||
res = ScoreResult{IsCorrect: true, Points: full}
|
||||
}
|
||||
case models.TypeMultiple:
|
||||
switch {
|
||||
case len(correct) > 0 && wrong == 0 && right == len(correct):
|
||||
res = ScoreResult{IsCorrect: true, Points: full}
|
||||
case cfg.MultiplePartial && len(correct) > 0:
|
||||
res.Points = round(full * math.Max(float64(right-wrong), 0) / float64(len(correct)))
|
||||
}
|
||||
}
|
||||
if !res.IsCorrect && res.Points == 0 && cfg.PenaltyWrong > 0 {
|
||||
res.Points = round(-full * cfg.PenaltyWrong)
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
// Totals sums the earned points of an attempt, floored at 0, and the
|
||||
// percentage of maxPoints it is. With no points to earn the percentage is 0.
|
||||
func Totals(points []float64, maxPoints int) (score, percent float64) {
|
||||
for _, p := range points {
|
||||
score += p
|
||||
}
|
||||
score = round(math.Max(score, 0))
|
||||
if maxPoints <= 0 {
|
||||
return score, 0
|
||||
}
|
||||
return score, round(score / float64(maxPoints) * 100)
|
||||
}
|
||||
|
||||
// round keeps two decimals.
|
||||
func round(f float64) float64 {
|
||||
r := math.Round(f*100) / 100
|
||||
if r == 0 {
|
||||
return 0 // no negative zero in JSON
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
func uniqueIDs(ids []uint) []uint {
|
||||
seen := make(map[uint]bool, len(ids))
|
||||
out := make([]uint, 0, len(ids))
|
||||
for _, id := range ids {
|
||||
if !seen[id] {
|
||||
seen[id] = true
|
||||
out = append(out, id)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
Reference in New Issue
Block a user