Merge pull request #13 from nuskey8/NRandom

Move to NRandom

Author: nuskey8

Directory.Build.props

@@ -2,15 +2,14 @@
 
     <PropertyGroup>
         <!-- NuGet Packaging -->
-        <PackageVersion>1.0.4</PackageVersion>
-        <Authors>Annulus Games</Authors>
-        <Copyright>© Annulus Games</Copyright>
-        <PackageProjectUrl>https://github.com/AnnulusGames/RandomExtensions</PackageProjectUrl>
+        <PackageVersion>2.0.0</PackageVersion>
+        <Authors>nuskey</Authors>
+        <Copyright>© Yusuke Nakada</Copyright>
+        <PackageProjectUrl>https://github.com/nuskey8/NRandom</PackageProjectUrl>
         <RepositoryUrl>$(PackageProjectUrl)</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <PackageReadmeFile>README.md</PackageReadmeFile>
-        <PackageIcon>Icon.png</PackageIcon>
     </PropertyGroup>
 
 </Project>

Icon.png

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Annulus Games
+Copyright (c) 2025 Yusuke Nakada
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

LICENSE

@@ -0,0 +1,13 @@
+<Solution>
+  <Folder Name="/sandbox/">
+    <Project Path="sandbox/Benchmark/Benchmark.csproj" />
+    <Project Path="sandbox/ConsoleApp1/ConsoleApp1.csproj" />
+  </Folder>
+  <Folder Name="/src/">
+    <Project Path="src/NRandom.Numerics/NRandom.Numerics.csproj" />
+    <Project Path="src/NRandom/NRandom.csproj" />
+  </Folder>
+  <Folder Name="/tests/">
+    <Project Path="tests/NRandom.Tests/NRandom.Tests.csproj" />
+  </Folder>
+</Solution>

NRandom.slnx

@@ -1,52 +1,56 @@
-# Random Extensions
+# NRandom
+
+[![NuGet](https://img.shields.io/nuget/v/NRandom.svg)](https://www.nuget.org/packages/NRandom)
+[![Releases](https://img.shields.io/github/release/nuskey8/NRandom.svg)](https://github.com/nuskey8/NRandom/releases)
+[![GitHub license](https://img.shields.io/github/license/nuskey8/NRandom.svg)](./LICENSE)
 
-[![NuGet](https://img.shields.io/nuget/v/RandomEx.svg)](https://www.nuget.org/packages/RandomEx)
-[![Releases](https://img.shields.io/github/release/AnnulusGames/RandomExtensions.svg)](https://github.com/AnnulusGames/RandomExtensions/releases)
-[![GitHub license](https://img.shields.io/github/license/AnnulusGames/RandomExtensions.svg)](./LICENSE)
 
 English | [日本語](README_JA.md)
 
 ## Overview
 
-Random Extensions is a library that provides functionality for pseudorandom number generation for .NET and Unity.
+NRandom is a library that provides functionality for pseudorandom number generation for .NET and Unity.
 
 .NET has a built-in `Random` class, but it is not sufficient in terms of functionality and contains complex implementations and unnecessary abstractions due to compatibility issues.
 
 Unity's `UnityEngine.Random` is a static class, making it impossible to instantiate. Additionally, it manages internal states, making it difficult to reproduce random numbers.
 
-Random Extensions introduces `IRandom` as a new abstraction layer for random number generation, providing high performance implementations based on various algorithms (xoshift, xoshiro, splitmix, PCG). It also offers many useful features for handling random numbers, such as extension methods that support `System.Numerics` and Unity types, `IWeightedCollection<T>` for handling weighted random numbers, and LINQ extensions for random numbers (`RandomEnumerable`).
+NRandom introduces `IRandom` as a new abstraction layer for random number generation, providing high performance implementations based on various algorithms (xoshift, xoshiro, splitmix, PCG). It also offers many useful features for handling random numbers, such as extension methods that support `System.Numerics` and Unity types, `IWeightedCollection<T>` for handling weighted random numbers, and LINQ extensions for random numbers (`RandomEnumerable`).
 
 > [!WARNING]
 > Do not use this library for security purposes. If you need cryptographically secure random numbers, use `System.Security.Cryptography.RandomNumberGenerator`.
 
+> [!NOTE]
+> For migration from RandomExtensions(v1), please see [here](./docs/migrating_randomextensions.md).
+
 ## Installation
 
 ### NuGet packages
 
-Random Extensions requires .NET Standard 2.1 or higher. The package is available on NuGet.
+NRandom requires .NET Standard 2.1 or higher. The package is available on NuGet.
 
 ### .NET CLI
 
 ```ps1
-dotnet add package RandomEx
+dotnet add package NRandom
 ```
 
 ### Package Manager
 
 ```ps1
-Install-Package RandomEx
+Install-Package NRandom
 ```
 
 ### Unity
 
-You can use Random Extensions in Unity by using NugetForUnity. For more details, refer to the [Unity](#unity-1) section.
+You can use NRandom in Unity by using NugetForUnity. For more details, refer to the [Unity](#unity-1) section.
 
 ## Basic Usage
 
 You can generate random numbers using `RandomEx.Shared`.
 
 ```cs
-using RandomExtensions;
+using NRandom;
 
 // Get a random value between 0-9
 var n = RandomEx.Shared.NextInt(0, 10);
@@ -70,7 +74,7 @@ var d = rand.NextDouble();
 
 ## Supported Types
 
-Random Extensions supports more types than the standard `System.Random`.
+NRandom supports more types than the standard `System.Random`.
 
 ```cs
 var rand = RandomEx.Create();
@@ -112,37 +116,7 @@ rand.NextBytes(buffer);          // Fill the buffer with random bytes
 
 Additionally, by introducing the extension package, you can use methods that support types in `System.Numerics` and Unity. For details, see the sections on [System.Numerics](#systemnumerics) and [Unity](#unity-1).
 
-## Collection Operations
-
-### Element Retrieval
-
-You can use the `GetItem()` method to retrieve a random element from an array. If you want to retrieve multiple elements at once, use `GetItems()`.
-
-```cs
-var rand = RandomEx.Create();
-
-// Create an array of values
-var values = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-
-// Get a random element
-var item = rand.GetItem(values);
-
-// Get 5 random elements (with duplicates)
-var items = rand.GetItems(values, 5);
-```
-
-You can also specify weights for each element. The array of weights you pass as an argument must match the number of elements in the original array.
-
-```cs
-var values = new int[] { 0, 1, 2 };
-var weights = new double[] { 1.0, 5.0, 1.0 };
-
-// Retrieve weighted random elements
-var item = rand.GetItem(values, weights);
-var items = rand.GetItem(values, weights, 5);
-```
-
-### Shuffling
+## Shuffling
 
 You can shuffle the elements of an array using the `Shuffle()` method.
 
@@ -155,22 +129,22 @@ rand.Shuffle(array);
 
 This method modifies the array itself. If you need a side-effect-free shuffle, use the following LINQ extension.
 
-### LINQ Extensions
+## LINQ Extensions
 
-Under the `RandomExtensions.Linq` namespace, there are LINQ extensions that utilize random numbers.
+Under the `NRandom.Linq` namespace, there are LINQ extensions that utilize random numbers.
 
 ```cs
 using System;
 using System.Linq;
-using RandomExtensions.Linq;
+using NRandom.Linq;
 
 var sequence = Enumerable.Range(0, 100);
 
 // Get a random element
 var r = sequence.RandomElement();
 
-// Shuffle the order
-foreach (var item in sequence.Shuffle())
+// Shuffle the order using NRandom
+foreach (var item in sequence.Shuffle(RandomEx.Shared))
 {
     Console.WriteLine(item);
 }
@@ -193,18 +167,17 @@ var r = sequence.RandomElement(rand);
 
 ## Weighted Collections
 
-Under the `RandomExtensions.Collections` namespace, there are collections that hold weighted elements.
+Under the `NRandom.Collections` namespace, there are collections that hold weighted elements.
 
 ```cs
 // Interface for a weighted collection
 public interface IWeightedCollection<T> : IReadOnlyCollection<WeightedValue<T>>
 {
-    T GetItem<TRandom>(TRandom random) where TRandom : IRandom;
-    void GetItems<TRandom>(TRandom random, Span<T> destination) where TRandom : IRandom;
+    void GetRandom<TRandom>(TRandom random, Span<T> destination) where TRandom : IRandom;
 }
 
 // Struct representing a weighted element
-public readonly record struct WeightedValue<T>(T Value, double Weight);
+public rrecord struct WeightedValue<T>(T Value, double Weight);
 ```
 
 Below is a sample of using `WeightedList<T>` for weighted selection.
@@ -214,19 +187,32 @@ Below is a sample of using `WeightedList<T>` for weighted selection.
 var weightedList = new WeightedList<string>();
 
 // Add elements with specified weights
-weightedList.Add("Legendary", 0.5f);
-weightedList.Add("Epic", 2.5f);
-weightedList.Add("Rare", 12f);
-weightedList.Add("Uncommon", 25f);
-weightedList.Add("Common", 60f);
+weightedList.Add("Legendary", 0.5);
+weightedList.Add("Epic", 2.5);
+weightedList.Add("Rare", 12);
+weightedList.Add("Uncommon", 25);
+weightedList.Add("Common", 60);
 
 // Retrieve a weighted random element
-var rarity = weightedList.GetItem();
+var rarity = weightedList.GetRandom();
+```
+
+You can also perform a weighted random draw without duplicates using `RemoveRandom()`.
+
+```cs
+var list = new WeightedList<string>();
+list.Add("Foo", 1.0);
+list.Add("Bar", 1.5);
+list.Add("Baz", 3.0);
+
+list.RemoveRandom(out var item0);
+list.RemoveRandom(out var item1);
+list.RemoveRandom(out var item2);
 ```
 
 ## IRandom
 
-Random Extensions provides `IRandom` as an interface for random number generators. By implementing this interface, you can create custom random number generator.
+NRandom provides `IRandom` as an interface for random number generators. By implementing this interface, you can create custom random number generator.
 
 ```cs
 public interface IRandom
@@ -239,29 +225,36 @@ public interface IRandom
 
 ### IRandom Implementations
 
-Random Extensions provides several `IRandom` implementations by default. Below is a list of class names and the pseudorandom number algorithms they use internally.
+NRandom provides several `IRandom` implementations by default. Below is a list of class names and the pseudorandom number algorithms they use internally.
 
 | Class Name | Algorithm |
 | - | - |
+| `ChaChaRandom` | ChaCha (default is ChaCha8) |
+| `MersenneTwisterRandom` | Mersenne Twister (MT19937) |
 | `Pcg32Random` | PCG32 (PCG-XSH-RR) |
+| `Philox4x32Random` | Philox4x32 (default is Philox4x32-10)  |
+| `Sfc32Random` | SFC32  |
+| `Sfc64Random` | SFC64  |
 | `SplitMix32Random` | splitmix32 |
 | `SplitMix64Random` | splitmix64 |
+| `TinyMt32Random` | Tiny Mersenne Twister (32bit) |
+| `TinyMt64Random` | Tiny Mersenne Twister (64bit) |
 | `Xorshift32Random` | xorshift32 |
 | `Xorshift64Random` | xorshift64 |
 | `Xorshift128Random` | xorshift128 |
 | `Xoshiro128StarStarRandom` | xoshiro128** |
 | `Xoshiro256StarStarRandom` | xoshiro256** |
 
-## RandomExtensions.Algorithms
+## NRandom.Algorithms
 
-Under the `RandomExtensions.Algorithms` namespace, there are implementations of algorithms for generating pseudorandom numbers.
+Under the `NRandom.Algorithms` namespace, there are implementations of algorithms for generating pseudorandom numbers.
 
 These are structs with minimal state and methods, useful in scenarios where performance is critical or state serialization is required.
 
 Below is a sample using the `XorShift32` struct to generate pseudorandom numbers.
 
 ```cs
-using RandomExtensions.Algorithms;
+using NRandom.Algorithms;
 
 var seed = 123456;
 var xorshift = new Xorshift32(seed);
@@ -271,18 +264,18 @@ var r = xorshift.Next();
 
 ## System.Numerics
 
-`RandomEx.Numerics` package, available on NuGet, provides extensions that support types in `System.Numerics`.
+`NRandom.Numerics` package, available on NuGet, provides extensions that support types in `System.Numerics`.
 
 #### .NET CLI
 
 ```ps1
-dotnet add package RandomEx.Numerics
+dotnet add package NRandom.Numerics
 ```
 
 #### Package Manager
 
 ```ps1
-Install-Package RandomEx.Numerics
+Install-Package NRandom.Numerics
 ```
 
 ### Basic Usage
@@ -291,8 +284,8 @@ After installation, you can use the methods below.
 
 ```cs
 using System.Numerics;
-using RandomExtensions;
-using RandomExtensions.Numerics;
+using NRandom;
+using NRandom.Numerics;
 
 var rand = RandomEx.Create();
 
@@ -321,7 +314,7 @@ rand.NextQuaternionRotation();  // Get a quaternion representing a random rotati
 
 ## Unity
 
-Random Extensions is available for use in Unity and provides an extension package.
+NRandom is available for use in Unity and provides an extension package.
 
 ### Requirements
 
@@ -331,23 +324,23 @@ Random Extensions is available for use in Unity and provides an extension packag
 
 1. Install [NugetForUnity](https://github.com/GlitchEnzo/NuGetForUnity).
 
-2. Open the NuGet window by selecting `NuGet > Manage NuGet Packages`, search for the `RandomEx` package, and install it.
+2. Open the NuGet window by selecting `NuGet > Manage NuGet Packages`, search for the `NRandom` package, and install it.
     ![img](docs/img-nugetforunity.png)
 
 3. Open the Package Manager window by selecting `Window > Package Manager`, then click on `[+] > Add package from git URL` and enter the following URL:
 
     ```
-    https://github.com/AnnulusGames/RandomExtensions.git?path=src/RandomExtensions.Unity/Assets/RandomExtensions.Unity
+    https://github.com/nuskey8/NRandom.git?path=src/NRandom.Unity/Assets/NRandom.Unity
     ```
 
 ### Extension Methods
 
-Under the `RandomExtensions.Unity` namespace, the following extension methods are available for Unity:
+Under the `NRandom.Unity` namespace, the following extension methods are available for Unity:
 
 ```cs
 using UnityEngine;
-using RandomExtensions;
-using RandomExtensions.Unity;
+using NRandom;
+using NRandom.Unity;
 
 var rand = RandomEx.Create();
 
@@ -381,6 +374,25 @@ rand.NextColorHSV(0f, 1f, 0f, 1f, 0f, 1f);          // Specify HSV range
 rand.NextColorHSV(0f, 1f, 0f, 1f, 0f, 1f, 0f, 1f);  // Specify HSV and alpha range
 ```
 
+### SerializableWeightedList
+
+In addition to the regular `WeightedList<T>`, NRandom.Unity also provide `SerializableWeightedList<T>`, whose values ​​can be edited in the Inspector.
+
+```cs
+using NRandom;
+using NRandom.Collections;
+using NRandom.Unity;
+using UnityEngine;
+
+public class Sandbox : MonoBehaviour
+{
+    [SerializeField] WeightedValue<string> value;
+    [SerializeField] SerializableWeightedList<string> list;
+}
+```
+
+![img](./docs/img-list-inspector.png)
+
 ## License
 
 This library is released under the MIT License.