add Printf implementation

frontend/api.go

@@ -128,6 +128,10 @@ type API interface {
 	// whose value will be resolved at runtime when computed by the solver
 	Println(a ...Variable)
 
+	// Println behaves like fmt.Printf but accepts cd.Variable as parameter
+	// whose value will be resolved at runtime when computed by the solver
+	Printf(format string, args ...Variable)
+
 	// Compiler returns the compiler object for advanced circuit development
 	Compiler() Compiler
 

frontend/cs/r1cs/api.go

@@ -628,6 +628,68 @@ func (builder *builder) Println(a ...frontend.Variable) {
 	builder.cs.AddLog(log)
 }
 
+func (builder *builder) Printf(format string, args ...frontend.Variable) {
+	var log constraint.LogEntry
+
+	// prefix log line with file.go:line
+	if _, file, line, ok := runtime.Caller(1); ok {
+		log.Caller = fmt.Sprintf("%s:%d", filepath.Base(file), line)
+	}
+
+	var sbb strings.Builder
+	formatIndex := 0
+
+	// Parse the format string and match placeholders with args
+	for _, arg := range args {
+		// Search for the next format specifier
+		nextPercent := strings.Index(format[formatIndex:], "%")
+		if nextPercent == -1 {
+			// No more placeholders; add remaining format string and break
+			sbb.WriteString(format[formatIndex:])
+			break
+		}
+
+		// Add the part of the format string before the next %
+		sbb.WriteString(format[formatIndex : formatIndex+nextPercent])
+		formatIndex += nextPercent + 1 // Move past %
+
+		// Handle format specifier
+		if formatIndex < len(format) {
+			specifier := format[formatIndex]
+			formatIndex++ // Move past the specifier
+
+			switch specifier {
+			case 's', 'd', 'f', 'x': // Supported format specifiers
+				if v, ok := arg.(expr.LinearExpression); ok {
+					assertIsSet(v)
+					sbb.WriteString("%" + string(specifier))
+					log.ToResolve = append(log.ToResolve, builder.getLinearExpression(v))
+				} else {
+					builder.printArg(&log, &sbb, arg)
+				}
+			default:
+				// Unsupported specifier; add it directly
+				sbb.WriteByte('%')
+				sbb.WriteByte(specifier)
+			}
+		} else {
+			// Malformed format string (ends with %)
+			sbb.WriteByte('%')
+		}
+	}
+
+	// Add remaining format string after the last placeholder
+	if formatIndex < len(format) {
+		sbb.WriteString(format[formatIndex:])
+	}
+
+	// Set the format string for the log entry
+	log.Format = sbb.String()
+
+	// Add the log entry to the circuit's constraint system
+	builder.cs.AddLog(log)
+}
+
 func (builder *builder) printArg(log *constraint.LogEntry, sbb *strings.Builder, a frontend.Variable) {
 
 	leafCount, err := schema.Walk(a, tVariable, nil)

frontend/cs/scs/api.go

@@ -539,6 +539,37 @@ func (builder *builder) Println(a ...frontend.Variable) {
 	builder.cs.AddLog(log)
 }
 
+func (builder *builder) Printf(format string, args ...frontend.Variable) {
+	var log constraint.LogEntry
+
+	// prefix log line with file.go:line
+	if _, file, line, ok := runtime.Caller(1); ok {
+		log.Caller = fmt.Sprintf("%s:%d", filepath.Base(file), line)
+	}
+
+	var sbb strings.Builder
+
+	for i, arg := range args {
+		if i > 0 {
+			sbb.WriteByte(' ')
+		}
+		if v, ok := arg.(expr.Term); ok {
+
+			sbb.WriteString("%s")
+			// we set limits to the linear expression, so that the log printer
+			// can evaluate it before printing it
+			log.ToResolve = append(log.ToResolve, constraint.LinearExpression{builder.cs.MakeTerm(v.Coeff, v.VID)})
+		} else {
+			builder.printArg(&log, &sbb, arg)
+		}
+	}
+
+	// set format string to be used with fmt.Sprintf, once the variables are solved in the R1CS.Solve() method
+	log.Format = sbb.String()
+
+	builder.cs.AddLog(log)
+}
+
 func (builder *builder) printArg(log *constraint.LogEntry, sbb *strings.Builder, a frontend.Variable) {
 
 	leafCount, err := schema.Walk(a, tVariable, nil)

test/engine.go

@@ -515,6 +515,25 @@ func (e *engine) print(sbb *strings.Builder, x interface{}) {
 	}
 }
 
+func (e *engine) Printf(format string, args ...frontend.Variable) {
+	var sbb strings.Builder
+	sbb.WriteString("(test.engine) ")
+
+	// prefix log line with file.go:line
+	if _, file, line, ok := runtime.Caller(1); ok {
+		sbb.WriteString(filepath.Base(file))
+		sbb.WriteByte(':')
+		sbb.WriteString(strconv.Itoa(line))
+		sbb.WriteByte(' ')
+	}
+
+	for i := 0; i < len(args); i++ {
+		e.print(&sbb, args[i])
+		sbb.WriteByte(' ')
+	}
+	fmt.Println(sbb.String())
+}
+
 func (e *engine) NewHint(f solver.Hint, nbOutputs int, inputs ...frontend.Variable) ([]frontend.Variable, error) {
 
 	if nbOutputs <= 0 {