Calc: add min/max

[guido4096]

I have a usecase where I need to use "max" in the calc plugin. This PR is to add that functionality and while at it, I think it should then also support "min".

If the idea of this PR is acceptable, I will also update the documentation. Note: current documentation misses noting that "div" and "abs" are already supported and hence will add that to the documentation section.

[sourcery-ai]

Hey there - I've reviewed your changes and they look great!

Prompt for AI Agents

Please address the comments from this code review:

## Individual Comments

### Comment 1
<location> `plugin/calc.go:74` </location>
<code_context>
 		o.div = append(o.div, f)
 	}

+	for idx, cc := range cc.Min {
+		f, err := cc.FloatGetter(ctx)
+		if err != nil {
</code_context>

<issue_to_address>
**issue (complexity):** Consider refactoring repeated loop and aggregation logic into reusable helper functions to simplify the code.

```suggestion
You can eliminate most of the near-duplicate loops by introducing two small helpers:

1) buildFuncs – turns a []Config into []func() (float64,error) with the proper error wrap  
2) aggregate – reduces a slice of float getters with an initial value + combiner

Example:

```go
// in calc.go

// helper to build and wrap getters
func buildFuncs(ctx context.Context, cfgs []Config, name string) ([]func() (float64, error), error) {
    var out []func() (float64, error)
    for i, cfg := range cfgs {
        f, err := cfg.FloatGetter(ctx)
        if err != nil {
            return nil, fmt.Errorf("%s[%d]: %w", name, i, err)
        }
        out = append(out, f)
    }
    return out, nil
}

// generic aggregator for add, mul, min, max
func aggregate(
    fs []func() (float64, error),
    init float64,
    combine func(acc, v float64) float64,
) (float64, error) {
    acc := init
    for i, f := range fs {
        v, err := f()
        if err != nil {
            return 0, fmt.Errorf("aggregate[%d]: %w", i, err)
        }
        if i == 0 {
            acc = v
        } else {
            acc = combine(acc, v)
        }
    }
    return acc, nil
}
```

Then in `NewCalcFromConfig`:

```go
o.add, _ = buildFuncs(ctx, cc.Add, "add")
o.mul, _ = buildFuncs(ctx, cc.Mul, "mul")
o.div, _ = buildFuncs(ctx, cc.Div, "div")
o.min, _ = buildFuncs(ctx, cc.Min, "min")
o.max, _ = buildFuncs(ctx, cc.Max, "max")
```

And in your switch-case:

```go
case len(o.min) > 0:
    return aggregate(o.min, 0, math.Min)
case len(o.max) > 0:
    return aggregate(o.max, 0, math.Max)
case len(o.add) > 0:
    return aggregate(o.add, 0, func(a, b float64) float64 { return a + b })
case len(o.mul) > 0:
    return aggregate(o.mul, 1, func(a, b float64) float64 { return a * b })
```

This collapses all of the repeated loops and switch blocks into two concise, reusable helpers while preserving the exact functionality.
</issue_to_address>

---

Sourcery is free for open source - if you like our reviews please consider sharing them ✨

• X
• Mastodon
• LinkedIn
• Facebook

_{Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.}

[guido4096]

Docs are in evcc-io/docs#917. The 916 version was created on an old branch and the easiest fix was to restart from scratch.