Refactor number.go to return errors instead of panicking

- Changed Number interface methods to return errors instead of panicking
- Float64() now returns (float64, error)
- Add, Sub, Mul, Pow, Compare, Bool() now return (Number, error) or (int, error)
- StringNum and Symbol now return errors for unsupported operations
- Added IsString() and IsSymbol() to Number interface
- Removed unused arithmetic.go file
- Updated operations.go, boolean_ops.go, hyper.go to handle errors
- Added constants registry (internal/rpn/constants.go) with built-in math constants
- Added constants_test.go with comprehensive unit tests
- Updated README.md with constants documentation

1 files changed, 60 insertions, 6 deletions

diff --git a/internal/rpn/boolean_ops.go b/internal/rpn/boolean_ops.go
index d07aa26..21501a9 100644
--- a/internal/rpn/boolean_ops.go
+++ b/internal/rpn/boolean_ops.go
@@ -28,7 +28,16 @@ func (o *BooleanOperations) GT(stack *Stack) error {
 		return fmt.Errorf("insufficient operands for gt: %w", err)
 	}
 
-	stack.Push(NewFloatFromBool(a.Float64() > b.Float64()))
+	aVal, err := a.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for a: %w", err)
+	}
+	bVal, err := b.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for b: %w", err)
+	}
+
+	stack.Push(NewFloatFromBool(aVal > bVal))
 	return nil
 }
 
@@ -44,7 +53,16 @@ func (o *BooleanOperations) LT(stack *Stack) error {
 		return fmt.Errorf("insufficient operands for lt: %w", err)
 	}
 
-	stack.Push(NewFloatFromBool(a.Float64() < b.Float64()))
+	aVal, err := a.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for a: %w", err)
+	}
+	bVal, err := b.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for b: %w", err)
+	}
+
+	stack.Push(NewFloatFromBool(aVal < bVal))
 	return nil
 }
 
@@ -60,7 +78,16 @@ func (o *BooleanOperations) GTE(stack *Stack) error {
 		return fmt.Errorf("insufficient operands for gte: %w", err)
 	}
 
-	stack.Push(NewFloatFromBool(a.Float64() >= b.Float64()))
+	aVal, err := a.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for a: %w", err)
+	}
+	bVal, err := b.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for b: %w", err)
+	}
+
+	stack.Push(NewFloatFromBool(aVal >= bVal))
 	return nil
 }
 
@@ -76,7 +103,16 @@ func (o *BooleanOperations) LTE(stack *Stack) error {
 		return fmt.Errorf("insufficient operands for lte: %w", err)
 	}
 
-	stack.Push(NewFloatFromBool(a.Float64() <= b.Float64()))
+	aVal, err := a.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for a: %w", err)
+	}
+	bVal, err := b.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for b: %w", err)
+	}
+
+	stack.Push(NewFloatFromBool(aVal <= bVal))
 	return nil
 }
 
@@ -92,7 +128,16 @@ func (o *BooleanOperations) EQ(stack *Stack) error {
 		return fmt.Errorf("insufficient operands for eq: %w", err)
 	}
 
-	stack.Push(NewFloatFromBool(a.Float64() == b.Float64()))
+	aVal, err := a.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for a: %w", err)
+	}
+	bVal, err := b.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for b: %w", err)
+	}
+
+	stack.Push(NewFloatFromBool(aVal == bVal))
 	return nil
 }
 
@@ -108,6 +153,15 @@ func (o *BooleanOperations) NEQ(stack *Stack) error {
 		return fmt.Errorf("insufficient operands for neq: %w", err)
 	}
 
-	stack.Push(NewFloatFromBool(a.Float64() != b.Float64()))
+	aVal, err := a.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for a: %w", err)
+	}
+	bVal, err := b.Float64()
+	if err != nil {
+		return fmt.Errorf("failed to get float64 value for b: %w", err)
+	}
+
+	stack.Push(NewFloatFromBool(aVal != bVal))
 	return nil
 }