Tree3.Converter 1.0.2

tree3-calc-converter

## tree3-calc-converter

tree3-calc-converter converts a decimal number provided as a string into its binary representation (and vice versa). 
It is implemented to handle arbitrarily large integers using `System.Numerics.BigInteger` and runs the conversion asynchronously.

### Prerequisites
- C# 13.0
- .NET 9

### Public API
- Class DecimalToBinary, `Task<string> RunAsync(string numberAsString)`
- Class BinaryToDecimal, `Task<string> RunAsync(string numberAsString)`

Behavior:
- Returns the binary string representation of the input decimal number on success.
- Returns `"N/A"` when the input is invalid or cannot be parsed as a decimal integer.
- Trims leading zeros before parsing.
- Handles large integers via `BigInteger`.
- Zero input returns `"0"`.

### Usage

Example C# usage:
```csharp
// Example 1: Valid decimal string
string binary = await converter.RunAsync("42");
// binary is "101010"

// Example 2: Decimal string with leading zeros
string binaryWithLeadingZeros = await converter.RunAsync("00042");
// binaryWithLeadingZeros is "101010"

// Example 3: Zero input
string zeroBinary = await converter.RunAsync("0");
// zeroBinary is "0"

// Example 4: Invalid input
string invalidBinary = await converter.RunAsync("abc");
// invalidBinary is "N/A"

// Example 5: Empty input
string emptyBinary = await converter.RunAsync("");
// emptyBinary is "N/A" (depends on BaseConverter.Validate)

// Example 6: Very large integer string
string largeBinary = await converter.RunAsync("12345678901234567890");
// largeBinary is the binary representation of the large number
```

### Examples and Expected Results

- Input: `"42"` -> Output: `"101010"`
- Input: `"00042"` -> Output: `"101010"`
- Input: `"0"` -> Output: `"0"`
- Input: `"abc"` -> Output: `"N/A"`
- Input: `""` (empty) -> Output: `"N/A"` (depends on `BaseConverter.Validate`)
- Input: very large integer string -> Output: large binary string (conversion uses `BigInteger` and may be CPU intensive for huge inputs)

### Implementation Notes

- Parsing is performed with `BigInteger.Parse`. If parsing fails, the method returns `"N/A"`.
- Conversion to binary uses bitwise operations and constructs the binary string efficiently with a `StringBuilder`.
- The heavy work is executed on a thread-pool thread via `Task.Run` so callers do not block on long conversions.
- The class relies on `BaseConverter.Validate` to determine initial validity and `BaseConverter.RemoveLeadingZeros` to normalize inputs.

### Troubleshooting

- If very large numbers cause high CPU or memory usage, consider imposing a length limit before parsing or using streaming/segment conversion if applicable.
- If `Validate` behavior is unexpected, inspect the `BaseConverter` implementation.
- Non-integer decimal strings (e.g., with decimal point or sign) will depend on `Validate` and `BigInteger.Parse` behavior; currently, parsing expects an integer format.