Nerd_STF 3.1.2

• .NETCoreApp 3.0

  • No dependencies.

• .NETFramework 4.6

  • System.Memory (>= 4.5.5)
  • System.ValueTuple (>= 4.5.0)

• .NETFramework 4.6.2

  • System.Memory (>= 4.6.2)
  • System.ValueTuple (>= 4.6.1)

• .NETFramework 4.7

  • System.Memory (>= 4.6.2)

• .NETStandard 1.1

  • NETStandard.Library (>= 1.6.1)
  • System.Drawing.Primitives (>= 4.3.0)
  • System.Memory (>= 4.5.5)
  • System.Net.Http (>= 4.3.4)
  • System.Numerics.Vectors (>= 4.5.0)
  • System.Text.RegularExpressions (>= 4.3.1)
  • System.ValueTuple (>= 4.5.0)

• .NETStandard 1.3

  • NETStandard.Library (>= 1.6.1)
  • System.Drawing.Primitives (>= 4.3.0)
  • System.Memory (>= 4.5.5)
  • System.Net.Http (>= 4.3.4)
  • System.Numerics.Vectors (>= 4.5.0)
  • System.Text.RegularExpressions (>= 4.3.1)
  • System.ValueTuple (>= 4.5.0)

• .NETStandard 2.1

  • No dependencies.

• net5.0

  • No dependencies.

• net7.0

  • No dependencies.

Welcome! I have some more small tweaks.

### You Don't Always Start With A `W`.

I finally got around to making `w` the last item in `Float4`s, `Int4`s, and `Quaternion`s. Really, it was a very peculiar hill I chose to die on there. My reasoning was mostly "w comes first in the alphabet, yeah? So it should contain the first value," but that's a silly argument because it's now no longer backwards compatible with 2s and 3s anymore. So I put it back. I had to do most of these changes manually, so I hope I didn't miss anything.

> [!WARNING]
> This is a breaking change! My *hope* is that anyone using this library was annoyed by this and now enjoys the new fix, but if you relied on this ordering, you might have to tweak some variables. Sorry about that.

### A Better `Sin()` function.

For a while now (basically since 3.0), the new Sin() function was quite inaccurate towards zero. It followed a proper Taylor series implementation and I think some floating point error was accumulating there. Not super certain. But I replaced it with another linear regression, like in 2.x. But it's a bit smarter: rather than making a polynomial represent the whole sin function, there are two polynomials that each represent an eighth of the range $[0..2\pi)$, and the rest of the range is mirrored to fit in one of those two categories. This way, the polynomial can be specifically taylored (hehe... taylored) to be good at either close to zero cases or close to one cases. It also uses less terms.

Shouldn't change your side very much, it'll just be more accurate. As far as I know, in normal situations the error never goes above 0.00004%.

### Some small stuff.

That's about all of the big stuff, not a super duper ton.

- I made the `IMagnitudeOperators` interface included in versions of C# < 11.
 - I might do that with the other interfaces, though I'm not quite sure if it's logical to include interfaces that would be completely empty in some versions of C#.
 - I also added the `Magnitude` and `MagnitudeSqr` property to the `IMagnitudeOperators` interface.
- I also added `MagnitudeSqr` to some more types, namely the `FloatX` and `IntX` types.
- I found a much simpler system for `MathE.ModAbs(num, mod)`. I unfortunately don't remember who I got it from, someone on StackOverflow that I found while looking for something else. It's constant-time rather than linear time. My previous approach was pretty dense if you ask me.

---

Anyway, that's all. Enjoy!