DefaultFloat64Op — Sparsi Library

Inputs

Field	Type	Description
`Value`	`*float64`	Primary value (may be nil)
`Default`	`*float64`	Fallback value

Outputs

Field	Type	Description
`Result`	`float64`	Value if non-nil, otherwise Default

Zero is valid. This op only falls back when Value is nil (upstream skipped), not when it is 0.0.

Typical Use Cases

Supplying a fallback score
Default weight when upstream skipped
Safe initialization for optional float wires

Complete Runnable Example

Ensures a confidence score always has a value: uses the model's output when available, falling back to 1.0 otherwise.

main.go

package main

import (
	"context"
	"encoding/json"
	"log"
	"os"
	"time"

	"github.com/akennis/sparsi-go/library"
	_ "github.com/akennis/dagor/operator/builtin"

	"github.com/panjf2000/ants/v2"
	"github.com/akennis/dagor"
	"github.com/akennis/dagor/graph"
)

func main() {
	value := 0.75
	defaultVal := 1.0
	library.RegisterConst("score_val", value)
	library.RegisterConst("default_score", defaultVal)

	g, err := graph.NewBuilder("defaultf64_demo").
		Vertex("src_v").Op("score_val").Output("Result", "wire_v").
		Vertex("src_d").Op("default_score").Output("Result", "wire_d").
		Vertex("def").Op("DefaultFloat64Op").
		Input("Value", "wire_v").Input("Default", "wire_d").
		Output("Result", "safe_score").
		Build()
	if err != nil {
		log.Fatalf("build: %v", err)
	}

	pool, err := ants.NewPool(4)
	if err != nil {
		log.Fatalf("pool: %v", err)
	}
	defer pool.Release()

	eng, err := dagor.NewEngine(g, pool)
	if err != nil {
		log.Fatalf("engine: %v", err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
	defer cancel()

	if err := eng.Run(ctx); err != nil {
		log.Fatalf("run: %v", err)
	}

	out := map[string]any{"value": value, "default": defaultVal}
	if raw, ok := eng.GetOutput("safe_score"); ok {
		out["safe_score"] = *raw.(*float64)
	}
	enc := json.NewEncoder(os.Stdout)
	enc.SetIndent("", "  ")
	enc.Encode(out)
}