Initial commit

Author: tygern

.gitignore

@@ -0,0 +1 @@
+.idea

README.md

@@ -0,0 +1,48 @@
+# Atomic Arithmetic
+
+Inspired by [Tailwind CSS](https://tailwindcss.com/).
+
+A utility-first arithmetic framework packed with functions like `Add23`, `Subtract8921`, `MultiplyBy5522`
+and `DivideBy7` that can be composed to compute any number, directly in your Go code.
+Atomic Arithmetic is unapologetically modern, and takes advantage of all the latest and greatest Go features
+to make the developer experience as enjoyable as possible.
+
+Build whatever you want, without touching pesky [arithmetic operators](https://go.dev/ref/spec#Arithmetic_operators).
+Currently supports numbers up to 10,000, which should be enough for most applications.
+
+## Usage
+
+Import the operations package to use the atomic arithmetic functions.
+Fast, built-in autocomplete in most IDEs!
+
+```go
+package main
+
+import "github.com/initialcapacity/atomic-arithmetic/pkg/operations"
+
+func main() {
+	operations.Add365(17)
+	operations.Subtract714(893)
+	operations.MultiplyBy199(87)
+	operations.DivideBy342(744)
+	operations.Mod17(654)
+}
+```
+
+Run the [demo](./cmd/demo/main.go) to see these examples in action.
+
+```shell
+go run ./cmd/demo
+```
+
+## Development
+
+1.  Re-generate the operations package.
+    ```shell
+    go ./cmd/generate
+    ```
+
+1.  Run the extensive test suite.
+    ```shell
+    go test ./...
+    ```

cmd/demo/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+	"github.com/initialcapacity/atomic-arithmetic/pkg/operations"
+)
+
+func main() {
+	fmt.Println("\nAdd 365 to 17")
+	fmt.Println(operations.Add365(17))
+
+	fmt.Println("\nSubtract 714 from 893")
+	fmt.Println(operations.Subtract714(893))
+
+	fmt.Println("\nMultiple 87 by 199")
+	fmt.Println(operations.MultiplyBy199(87))
+
+	fmt.Println("\nDivide 744 by 342")
+	fmt.Println(operations.DivideBy342(744))
+
+	fmt.Println("\nCalculate 654 modulo 17")
+	fmt.Println(operations.Mod17(654))
+}

cmd/generate/main.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"github.com/initialcapacity/atomic-arithmetic/internal/go_support"
+	"log"
+)
+
+func main() {
+	operationsDir, err := go_support.CreatePackageDirectory("operations")
+	if err != nil {
+		log.Fatalf("Unable to create pkg/operations directory: %v\n", err)
+	}
+
+	maximumNumber := 10_000
+
+	go_support.CreateAtomicFile(operationsDir, "operations", "add.go", "Add", "+", maximumNumber)
+	go_support.CreateAtomicTest(operationsDir, "operations", "add_test.go", "Add", func(i, j int) int { return i + j }, maximumNumber)
+
+	go_support.CreateAtomicFile(operationsDir, "operations", "subtract.go", "Subtract", "-", maximumNumber)
+	go_support.CreateAtomicTest(operationsDir, "operations", "subtract_test.go", "Subtract", func(i, j int) int { return i - j }, maximumNumber)
+
+	go_support.CreateAtomicFile(operationsDir, "operations", "multiply.go", "MultiplyBy", "*", maximumNumber)
+	go_support.CreateAtomicTest(operationsDir, "operations", "multiply_test.go", "MultiplyBy", func(i, j int) int { return i * j }, maximumNumber)
+
+	go_support.CreateAtomicFile(operationsDir, "operations", "divide.go", "DivideBy", "/", maximumNumber)
+	go_support.CreateAtomicTest(operationsDir, "operations", "divide_test.go", "DivideBy", func(i, j int) int { return i / j }, maximumNumber)
+
+	go_support.CreateAtomicFile(operationsDir, "operations", "modulo.go", "Mod", "%", maximumNumber)
+	go_support.CreateAtomicTest(operationsDir, "operations", "modulo_test.go", "Mod", func(i, j int) int { return i % j }, maximumNumber)
+
+	log.Println("Success!")
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/initialcapacity/atomic-arithmetic
+
+go 1.23.5

internal/go_support/atomic_file.go

@@ -0,0 +1,19 @@
+package go_support
+
+import (
+	"log"
+	"path/filepath"
+)
+
+func CreateAtomicFile(directory, packageName, fileName, functionPrefix, operator string, count int) {
+	builder := NewFileBuilder(packageName)
+
+	for i := 1; i <= count; i++ {
+		builder.AppendFunction(functionPrefix, operator, i)
+	}
+
+	err := builder.WriteFile(filepath.Join(directory, fileName))
+	if err != nil {
+		log.Fatalf("Unable to create %s/%s: %v\n", packageName, fileName, err)
+	}
+}

internal/go_support/atomic_test_file.go

@@ -0,0 +1,19 @@
+package go_support
+
+import (
+	"log"
+	"path/filepath"
+)
+
+func CreateAtomicTest(directory, packageName, fileName, functionPrefix string, resultCalculator func(int, int) int, count int) {
+	addBuilder := NewTestBuilder(packageName)
+
+	for i := 1; i <= count; i++ {
+		addBuilder.AppendTestFunction(functionPrefix, i, 17_000, resultCalculator(17_000, i))
+	}
+
+	err := addBuilder.WriteFile(filepath.Join(directory, fileName))
+	if err != nil {
+		log.Fatalf("Unable to create %s/%s: %v\n", packageName, fileName, err)
+	}
+}

internal/go_support/directory_support.go

@@ -0,0 +1,21 @@
+package go_support
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+func CreatePackageDirectory(packageName string) (string, error) {
+	pkgDir := filepath.Join(".", "pkg")
+	err := os.RemoveAll(pkgDir)
+	if err != nil {
+		return "", fmt.Errorf("failed to remove pkg directory: %v", err)
+	}
+	operationsDir := filepath.Join(pkgDir, packageName)
+	err = os.MkdirAll(operationsDir, 0755)
+	if err != nil {
+		return "", fmt.Errorf("failed to create %s directory: %v\n", packageName, err)
+	}
+	return operationsDir, nil
+}

internal/go_support/file_builder.go

@@ -0,0 +1,30 @@
+package go_support
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+type FileBuilder struct {
+	stringBuilder strings.Builder
+}
+
+func NewFileBuilder(packageName string) *FileBuilder {
+	b := &FileBuilder{}
+	b.stringBuilder.WriteString(fmt.Sprintf(`package %s
+`, packageName))
+	return b
+}
+
+func (b *FileBuilder) AppendFunction(functionPrefix, operator string, n int) {
+	b.stringBuilder.WriteString(fmt.Sprintf(`
+func %s%d(operand int) int {
+	return operand %s %d
+}
+`, functionPrefix, n, operator, n))
+}
+
+func (b *FileBuilder) WriteFile(path string) error {
+	return os.WriteFile(path, []byte(b.stringBuilder.String()), 0644)
+}

internal/go_support/test_builder.go

@@ -0,0 +1,39 @@
+package go_support
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+type TestBuilder struct {
+	stringBuilder strings.Builder
+}
+
+func NewTestBuilder(packageName string) *TestBuilder {
+	b := &TestBuilder{}
+	b.stringBuilder.WriteString(fmt.Sprintf(`package %s_test
+
+import (
+	"github.com/initialcapacity/atomic-arithmetic/pkg/%s"
+	"testing"
+)
+`, packageName, packageName))
+	return b
+}
+
+func (b *TestBuilder) AppendTestFunction(functionPrefix string, n, input, result int) {
+	b.stringBuilder.WriteString(fmt.Sprintf(`
+func Test%s%d(t *testing.T) {
+	result := operations.%s%d(%d)
+	
+	if result != %d {
+		t.Errorf("Expected %d but got %%d", result)
+	}
+}
+`, functionPrefix, n, functionPrefix, n, input, result, result))
+}
+
+func (b *TestBuilder) WriteFile(path string) error {
+	return os.WriteFile(path, []byte(b.stringBuilder.String()), 0644)
+}