定点数,定点数二维向量,定点数三维向量,定点数数学类

这篇具有很好参考价值的文章主要介绍了定点数,定点数二维向量,定点数三维向量,定点数数学类。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

介绍

众所周知定点数是用于做帧同步时保持不同cpu不同设备保持一致稳定的代替浮点数的变量,这里提供了之前封装好的定点数、定点数二维向量、定点数三位向量、定点数数学类。这里不是物理库,知识定点数变量。
定点数类库

浮点数

浮点数也就是float占用4个字节,而定点数是8long类型占用8个字节。不同的cpu机器在计算浮点数的时候都会有微小的差错,比如unity面板中设置一个对象的位置Position,有时候你输入的是一个整数,后来变成了接近你这个整数的.99或者.998等(用Unity时间久的应该是能感受到)。这是因为你输入之后cpu是要经过计算显示出来的。那么这种情况下我们在做帧同步的时候每个机型不一样,计算出来的float也会有差别,帧同步中有微乎其微的差别计算到最后也会是巨大的差别,会影响整个比赛的结果。

定点数

定点数通常使用long类型来计算,这里说明一下为什么是long类型,比如说一个浮点数9.988879,那么定点数可以这样标识,前4个字节记录9988879、后4个字节记录小数点(.)在第几位,最后拼接成我们想要的结果,这样就能保证不同的机器中运算结果一致。

封装的定点数FixedNumber

具体的使用方式其实跟Int float差不太多,只是API可能略有不同,下面是定点数完整的代码,具体的用法我就不做详细说明了,我简单的说明一下
用法

// Update is called once per frame
void Update()
{
    if (Input.GetKeyDown(KeyCode.Space))
    {
        FixedNumber fn = new FixedNumber(f);
        Debug.LogError(fn);
        Debug.LogError(fn.GetValue());
        Debug.LogError(fn.ToFloat());
    }
}

定点数代码

using System;

/// <summary>
/// 定点数 使用Int64实现
/// </summary>
[Serializable]
public struct FixedNumber
{
    /// <summary>
    /// 小数占用位数
    /// </summary>
    public static int Fix_Fracbits = 16;
    /// <summary>
    /// 0
    /// </summary>
    public static FixedNumber Zero = new FixedNumber(0);
    internal Int64 m_Bits;

    public FixedNumber(int x)
    {
        m_Bits = (x << Fix_Fracbits);
    }
    public FixedNumber(float x)
    {
        m_Bits = (Int64)((x) * (1 << Fix_Fracbits));
    }
    public FixedNumber(Int64 x)
    {
        m_Bits = ((x) * (1 << Fix_Fracbits));
    }
    public Int64 GetValue()
    {
        return m_Bits;
    }
    public FixedNumber SetValue(Int64 i)
    {
        m_Bits = i;
        return this;
    }
    public static FixedNumber Lerp(FixedNumber a, FixedNumber b, float t)
    {
        return a + (b - a) * t;
    }
    public static FixedNumber Lerp(FixedNumber a, FixedNumber b, FixedNumber t)
    {
        return a + (b - a) * t;
    }
    public FixedNumber Abs()
    {

        return FixedNumber.Abs(this);
    }
    public FixedNumber Sqrt()
    {
        return FixedNumber.Sqrt(this);
    }
    //******************* +  **************************
    public static FixedNumber operator +(FixedNumber p1, FixedNumber p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = p1.m_Bits + p2.m_Bits;
        return tmp;
    }
    public static FixedNumber operator +(FixedNumber p1, int p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = p1.m_Bits + (Int64)(p2 << Fix_Fracbits);
        return tmp;
    }
    public static FixedNumber operator +(int p1, FixedNumber p2)
    {
        return p2 + p1;
    }
    public static FixedNumber operator +(FixedNumber p1, Int64 p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = p1.m_Bits + p2 << Fix_Fracbits;
        return tmp;
    }
    public static FixedNumber operator +(Int64 p1, FixedNumber p2)
    {
        return p2 + p1;
    }

    public static FixedNumber operator +(FixedNumber p1, float p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = p1.m_Bits + (Int64)(p2 * (1 << Fix_Fracbits));
        return tmp;
    }
    public static FixedNumber operator +(float p1, FixedNumber p2)
    {
        FixedNumber tmp = p2 + p1;
        return tmp;
    }
    //*******************  -  **************************
    public static FixedNumber operator -(FixedNumber p1, FixedNumber p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = p1.m_Bits - p2.m_Bits;
        return tmp;
    }

    public static FixedNumber operator -(FixedNumber p1, int p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = p1.m_Bits - (Int64)(p2 << Fix_Fracbits);
        return tmp;
    }

    public static FixedNumber operator -(int p1, FixedNumber p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = (p1 << Fix_Fracbits) - p2.m_Bits;
        return tmp;
    }
    public static FixedNumber operator -(FixedNumber p1, Int64 p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = p1.m_Bits - (p2 << Fix_Fracbits);
        return tmp;
    }
    public static FixedNumber operator -(Int64 p1, FixedNumber p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = (p1 << Fix_Fracbits) - p2.m_Bits;
        return tmp;
    }

    public static FixedNumber operator -(float p1, FixedNumber p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = (Int64)(p1 * (1 << Fix_Fracbits)) - p2.m_Bits;
        return tmp;
    }
    public static FixedNumber operator -(FixedNumber p1, float p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = p1.m_Bits - (Int64)(p2 * (1 << Fix_Fracbits));
        return tmp;
    }

    //******************* * **************************
    public static FixedNumber operator *(FixedNumber p1, FixedNumber p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = ((p1.m_Bits) * (p2.m_Bits)) >> (Fix_Fracbits);
        return tmp;
    }

    public static FixedNumber operator *(int p1, FixedNumber p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = p1 * p2.m_Bits;
        return tmp;
    }
    public static FixedNumber operator *(FixedNumber p1, int p2)
    {
        return p2 * p1;
    }
    public static FixedNumber operator *(FixedNumber p1, float p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = (Int64)(p1.m_Bits * p2);
        return tmp;
    }
    public static FixedNumber operator *(float p1, FixedNumber p2)
    {
        FixedNumber tmp;
        tmp.m_Bits = (Int64)(p1 * p2.m_Bits);
        return tmp;
    }
    //******************* / **************************
    public static FixedNumber operator /(FixedNumber p1, FixedNumber p2)
    {
        FixedNumber tmp;
        if (p2 == FixedNumber.Zero)
        {
            //UnityEngine.Debug.LogError("/0");
            tmp.m_Bits = Zero.m_Bits;
        }
        else
        {
            tmp.m_Bits = (p1.m_Bits) * (1 << Fix_Fracbits) / (p2.m_Bits);
        }
        return tmp;
    }
    public static FixedNumber operator /(FixedNumber p1, int p2)
    {
        FixedNumber tmp;
        if (p2 == 0)
        {
            //UnityEngine.Debug.LogError("/0");
            tmp.m_Bits = Zero.m_Bits;
        }
        else
        {
            tmp.m_Bits = p1.m_Bits / (p2);
        }
        return tmp;
    }
    public static FixedNumber operator %(FixedNumber p1, int p2)
    {
        FixedNumber tmp;
        if (p2 == 0)
        {
            //UnityEngine.Debug.LogError("/0");
            tmp.m_Bits = Zero.m_Bits;
        }
        else
        {
            tmp.m_Bits = (p1.m_Bits % (p2 << Fix_Fracbits));
        }
        return tmp;
    }
    public static FixedNumber operator /(int p1, FixedNumber p2)
    {
        FixedNumber tmp;
        if (p2 == Zero)
        {
            //UnityEngine.Debug.LogError("/0");
            tmp.m_Bits = Zero.m_Bits;
        }
        else
        {
            Int64 tmp2 = ((Int64)p1 << Fix_Fracbits << Fix_Fracbits);
            tmp.m_Bits = tmp2 / (p2.m_Bits);
        }
        return tmp;
    }
    public static FixedNumber operator /(FixedNumber p1, Int64 p2)
    {
        FixedNumber tmp;
        if (p2 == 0)
        {
            //UnityEngine.Debug.LogError("/0");
            tmp.m_Bits = Zero.m_Bits;
        }
        else
        {
            tmp.m_Bits = p1.m_Bits / (p2);
        }
        return tmp;
    }
    public static FixedNumber operator /(Int64 p1, FixedNumber p2)
    {
        FixedNumber tmp;
        if (p2 == Zero)
        {
            //UnityEngine.Debug.LogError("/0");
            tmp.m_Bits = Zero.m_Bits;
        }
        else
        {
            if (p1 > Int32.MaxValue || p1 < Int32.MinValue)
            {
                tmp.m_Bits = 0;
                return tmp;
            }
            tmp.m_Bits = (p1 << Fix_Fracbits) / (p2.m_Bits);
        }
        return tmp;
    }
    public static FixedNumber operator /(float p1, FixedNumber p2)
    {
        FixedNumber tmp;
        if (p2 == Zero)
        {
            //UnityEngine.Debug.LogError("/0");
            tmp.m_Bits = Zero.m_Bits;
        }
        else
        {
            Int64 tmp1 = (Int64)p1 * ((Int64)1 << Fix_Fracbits << Fix_Fracbits);
            tmp.m_Bits = (tmp1) / (p2.m_Bits);
        }
        return tmp;
    }
    public static FixedNumber operator /(FixedNumber p1, float p2)
    {
        FixedNumber tmp;
        if (p2 > -0.000001f && p2 < 0.000001f)
        {
            //UnityEngine.Debug.LogError("/0");
            tmp.m_Bits = Zero.m_Bits;
        }
        else
        {
            tmp.m_Bits = (p1.m_Bits << Fix_Fracbits) / ((Int64)(p2 * (1 << Fix_Fracbits)));
        }
        return tmp;
    }
    public static FixedNumber Sqrt(FixedNumber p1)
    {
        FixedNumber tmp;
        Int64 ltmp = p1.m_Bits * (1 << Fix_Fracbits);
        tmp.m_Bits = (Int64)Math.Sqrt(ltmp);
        return tmp;
    }
    public static bool operator >(FixedNumber p1, FixedNumber p2)
    {
        return (p1.m_Bits > p2.m_Bits) ? true : false;
    }
    public static bool operator <(FixedNumber p1, FixedNumber p2)
    {
        return (p1.m_Bits < p2.m_Bits) ? true : false;
    }
    public static bool operator <=(FixedNumber p1, FixedNumber p2)
    {
        return (p1.m_Bits <= p2.m_Bits) ? true : false;
    }
    public static bool operator >=(FixedNumber p1, FixedNumber p2)
    {
        return (p1.m_Bits >= p2.m_Bits) ? true : false;
    }
    public static bool operator !=(FixedNumber p1, FixedNumber p2)
    {
        return (p1.m_Bits != p2.m_Bits) ? true : false;
    }
    public static bool operator ==(FixedNumber p1, FixedNumber p2)
    {
        return (p1.m_Bits == p2.m_Bits) ? true : false;
    }

    public static bool Equals(FixedNumber p1, FixedNumber p2)
    {
        return (p1.m_Bits == p2.m_Bits) ? true : false;
    }

    public bool Equals(FixedNumber right)
    {
        if (m_Bits == right.m_Bits)
        {
            return true;
        }
        return false;
    }

    public static bool operator >(FixedNumber p1, float p2)
    {
        return (p1.m_Bits > (p2 * (1 << Fix_Fracbits))) ? true : false;
    }
    public static bool operator <(FixedNumber p1, float p2)
    {
        return (p1.m_Bits < (p2 * (1 << Fix_Fracbits))) ? true : false;
    }
    public static bool operator <=(FixedNumber p1, float p2)
    {
        return (p1.m_Bits <= p2 * (1 << Fix_Fracbits)) ? true : false;
    }
    public static bool operator >=(FixedNumber p1, float p2)
    {
        return (p1.m_Bits >= p2 * (1 << Fix_Fracbits)) ? true : false;
    }
    public static bool operator !=(FixedNumber p1, float p2)
    {
        return (p1.m_Bits != p2 * (1 << Fix_Fracbits)) ? true : false;
    }
    public static bool operator ==(FixedNumber p1, float p2)
    {
        return (p1.m_Bits == p2 * (1 << Fix_Fracbits)) ? true : false;
    }

    public static FixedNumber Max()
    {
        FixedNumber tmp;
        tmp.m_Bits = Int64.MaxValue;
        return tmp;
    }

    public static FixedNumber Max(FixedNumber p1, FixedNumber p2)
    {
        return p1.m_Bits > p2.m_Bits ? p1 : p2;
    }
    public static FixedNumber Min(FixedNumber p1, FixedNumber p2)
    {
        return p1.m_Bits < p2.m_Bits ? p1 : p2;
    }

    public static FixedNumber Precision()
    {
        FixedNumber tmp;
        tmp.m_Bits = 1;
        return tmp;
    }

    public static FixedNumber MaxValue()
    {
        FixedNumber tmp;
        tmp.m_Bits = Int64.MaxValue;
        return tmp;
    }
    public static FixedNumber Abs(FixedNumber P1)
    {
        FixedNumber tmp;
        tmp.m_Bits = Math.Abs(P1.m_Bits);
        return tmp;
    }
    public static FixedNumber operator -(FixedNumber p1)
    {
        FixedNumber tmp;
        tmp.m_Bits = -p1.m_Bits;
        return tmp;
    }

    public float ToFloat()
    {
        return m_Bits / (float)(1 << Fix_Fracbits);
    }
    public UnityEngine.Quaternion ToUnityRotation()
    {
        return UnityEngine.Quaternion.Euler(0, -this.ToFloat(), 0);
    }
    public int ToInt()
    {
        return (int)(m_Bits >> (Fix_Fracbits));
    }
    public override string ToString()
    {
        double tmp = (double)m_Bits / (double)(1 << Fix_Fracbits);
        return tmp.ToString();
    }
}

定点数二维向量

using UnityEngine;

/// <summary>
/// 定点数二维向量
/// </summary>
[System.Serializable]
public struct Fixed2
{
    public FixedNumber x;
    public FixedNumber y;

    public Fixed2(float x, float y)
    {

        this.x = new FixedNumber(x);
        this.y = new FixedNumber(y);

    }
    public Fixed2(FixedNumber x, FixedNumber y)
    {
        this.x = x;
        this.y = y;

    }
    public Vector3 ToVector3()
    {
        return new Vector3(x.ToFloat(), 0, y.ToFloat());
    }
    public static Fixed2 GetV2(FixedNumber x, FixedNumber y)
    {
        return new Fixed2(x, y);
    }
    public static Fixed2 operator +(Fixed2 a, Fixed2 b)
    {
        return new Fixed2(a.x + b.x, a.y + b.y);
    }
    public static Fixed2 operator -(Fixed2 a, Fixed2 b)
    {
        return new Fixed2(a.x - b.x, a.y - b.y);
    }
    public static Fixed2 operator *(Fixed2 a, FixedNumber b)
    {
        return new Fixed2(a.x * b, a.y * b);
    }
    public Fixed2 Rotate(FixedNumber value)
    {

        FixedNumber tx, ty;
        tx = MathFixed.CosAngle(value) * x - y * MathFixed.SinAngle(value);
        ty = MathFixed.CosAngle(value) * y + x * MathFixed.SinAngle(value);
        //1,0   tx=1*0-0  ty
        return new Fixed2(tx, ty);
    }

    public FixedNumber ToRotation()
    {
        if (x == 0 && y == 0)
        {
            return new FixedNumber();
        }
        FixedNumber sin = this.normalized.y;
        if (this.x >= 0)
        {
            return MathFixed.Asin(sin) / MathFixed.PI * 180;
        }
        else
        {
            return MathFixed.Asin(-sin) / MathFixed.PI * 180 + 180;
        }
    }
    public static Fixed2 Parse(FixedNumber ratio)
    {
        return new Fixed2(MathFixed.CosAngle(ratio), MathFixed.SinAngle(ratio));
    }
    public Fixed2 normalized
    {

        get
        {
            if (x == 0 && y == 0)
            {
                return new Fixed2();
            }
            FixedNumber n = ((x * x) + (y * y)).Sqrt();
            return new Fixed2(x / n, y / n);

        }
    }

    public static Fixed2 left = new Fixed2(-1, 0);
    public static Fixed2 right = new Fixed2(1, 0);
    public static Fixed2 up = new Fixed2(0, 1);
    public static Fixed2 down = new Fixed2(0, -1);
    public static Fixed2 zero = new Fixed2(0, 0);

    public FixedNumber Dot(Fixed2 b)
    {
        return Dot(this, b);
    }
    public static FixedNumber Dot(Fixed2 a, Fixed2 b)
    {
        return a.x * b.x + b.y * a.y;
    }

    public static Fixed2 operator -(Fixed2 a)
    {
        return new Fixed2(-a.x, -a.y);
    }
    public static Fixed3 operator *(Fixed2 a, Fixed2 b)
    {
        return new Fixed3(new FixedNumber(), new FixedNumber(), a.x * b.y - a.y * b.x);
    }
    public static bool operator ==(Fixed2 a, Fixed2 b)
    {
        return a.x == b.x && a.y == b.y;
    }
    public static bool operator !=(Fixed2 a, Fixed2 b)
    {
        return a.x != b.x || a.y != b.y;
    }
    public override string ToString()
    {
        return "{" + x.ToString() + "," + y.ToString() + "}";
    }

}

定点数三维向量

using UnityEngine;

/// <summary>
/// 定点数三维向量
/// </summary>
public struct Fixed3
{
    public FixedNumber x
    {
        get;
        private set;
    }
    public FixedNumber y
    {
        get;
        private set;
    }
    public FixedNumber z
    {
        get;
        private set;
    }

    public Fixed3(int x = 0, int y = 0, int z = 0)
    {
        this.x = new FixedNumber(x);
        this.y = new FixedNumber(y);
        this.z = new FixedNumber(z);

    }
    public Fixed3(float x, float y, float z)
    {

        this.x = new FixedNumber(x);
        this.y = new FixedNumber(y);
        this.z = new FixedNumber(z);

    }
    public Fixed3(FixedNumber x, FixedNumber y, FixedNumber z)
    {
        this.x = x;
        this.y = y;
        this.z = z;
    }
    public Vector3 ToVector3()
    {
        return new Vector3(x.ToFloat(), 0, y.ToFloat());
    }

    public static Fixed3 operator +(Fixed3 a, Fixed3 b)
    {
        return new Fixed3(a.x + b.x, a.y + b.y, a.z + b.z);
    }
    public static Fixed3 operator -(Fixed3 a, Fixed3 b)
    {
        return new Fixed3(a.x - b.x, a.y - b.y, a.z - b.z);
    }

    public static Fixed3 left = new Fixed3(-1, 0);
    public static Fixed3 right = new Fixed3(1, 0);
    public static Fixed3 up = new Fixed3(0, 1);
    public static Fixed3 down = new Fixed3(0, -1);
    public static Fixed3 zero = new Fixed3(0, 0);

    public FixedNumber Dot(Fixed3 b)
    {
        return Dot(this, b);
    }
    public static FixedNumber Dot(Fixed3 a, Fixed3 b)
    {
        return a.x * b.x + b.y * a.y;
    }

    public static Fixed3 operator -(Fixed3 a)
    {
        return new Fixed3(-a.x, -a.y, -a.z);
    }
    public static Fixed2 operator *(Fixed3 a, Fixed2 b)
    {
        return new Fixed2(-a.z * b.y, a.z * b.x);
    }
    public override string ToString()
    {
        return "{" + x.ToString() + "," + y.ToString() + "}";
    }
}

定点数数学类

using System.Collections.Generic;

/// <summary>
/// 定点数数学类
/// </summary>
class MathFixed
{
    protected static int tabCount = 18 * 4;
    /// <summary>
    /// sin值对应表
    /// </summary>
    protected static readonly List<FixedNumber> _m_SinTab = new List<FixedNumber>();
    public static readonly FixedNumber PI = new FixedNumber(3.14159265f);
    protected static FixedNumber GetSinTab(FixedNumber r)
    {

        FixedNumber i = new FixedNumber(r.ToInt());
        //UnityEngine.Debug.Log(i.ToInt());
        if (i.ToInt() == _m_SinTab.Count - 1)
        {
            return _m_SinTab[(int)i.ToInt()];
        }
        else
        {
            // UnityEngine.Debug.Log(i.ToInt()+":"+ _m_SinTab[i.ToInt()]+":"+ Ratio.Lerp(_m_SinTab[i.ToInt()], _m_SinTab[(i + 1).ToInt()], r - i));
            return FixedNumber.Lerp(_m_SinTab[(int)i.ToInt()], _m_SinTab[(int)(i + 1).ToInt()], r - i);
        }

    }
    public static FixedNumber GetAsinTab(FixedNumber sin)
    {
        MathFixed math = Instance;
        //UnityEngine.Debug.Log("GetAsinTab");
        for (int i = _m_SinTab.Count - 1; i >= 0; i--)
        {

            if (sin > _m_SinTab[i])
            {
                if (i == _m_SinTab.Count - 1)
                {
                    return new FixedNumber(i) / (tabCount / 4) * (PI / 2);
                }
                else
                {
                    //return new Ratio(i);
                    return FixedNumber.Lerp(new FixedNumber(i), new FixedNumber(i + 1), (sin - _m_SinTab[i]) / (_m_SinTab[i + 1] - _m_SinTab[i])) / (tabCount / 4) * (PI / 2);
                }
            }
        }
        return new FixedNumber();
    }
    protected static MathFixed Instance
    {
        get
        {
            if (_m_instance == null)
            {
                _m_instance = new MathFixed();

            }
            return _m_instance;
        }
    }
    protected static MathFixed _m_instance;
    protected MathFixed()
    {
        if (_m_instance == null)
        {

            _m_SinTab.Add(new FixedNumber(0f));//0
            _m_SinTab.Add(new FixedNumber(0.08715f));
            _m_SinTab.Add(new FixedNumber(0.17364f));
            _m_SinTab.Add(new FixedNumber(0.25881f));
            _m_SinTab.Add(new FixedNumber(0.34202f));//20
            _m_SinTab.Add(new FixedNumber(0.42261f));
            _m_SinTab.Add(new FixedNumber(0.5f));

            _m_SinTab.Add(new FixedNumber(0.57357f));//35
            _m_SinTab.Add(new FixedNumber(0.64278f));
            _m_SinTab.Add(new FixedNumber(0.70710f));
            _m_SinTab.Add(new FixedNumber(0.76604f));
            _m_SinTab.Add(new FixedNumber(0.81915f));//55
            _m_SinTab.Add(new FixedNumber(0.86602f));//60

            _m_SinTab.Add(new FixedNumber(0.90630f));
            _m_SinTab.Add(new FixedNumber(0.93969f));
            _m_SinTab.Add(new FixedNumber(0.96592f));
            _m_SinTab.Add(new FixedNumber(0.98480f));//80
            _m_SinTab.Add(new FixedNumber(0.99619f));

            _m_SinTab.Add(new FixedNumber(1f));


        }
    }
    public static FixedNumber PiToAngel(FixedNumber pi)
    {
        return pi / PI * 180;
    }
    public static FixedNumber Asin(FixedNumber sin)
    {
        if (sin < -1 || sin > 1) { return new FixedNumber(); }
        if (sin >= 0)
        {
            return GetAsinTab(sin);
        }
        else
        {
            return -GetAsinTab(-sin);
        }
    }
    public static FixedNumber Sin(FixedNumber r)
    {

        MathFixed math = Instance;
        //int tabCount = SinTab.Count*4;
        FixedNumber result = new FixedNumber();
        r = (r * tabCount / 2 / PI);
        //int n = r.ToInt();
        while (r < 0)
        {
            r += tabCount;
        }
        while (r > tabCount)
        {
            r -= tabCount;
        }
        if (r >= 0 && r <= tabCount / 4)                // 0 ~ PI/2
        {
            result = GetSinTab(r);
        }
        else if (r > tabCount / 4 && r < tabCount / 2)       // PI/2 ~ PI
        {
            r -= new FixedNumber(tabCount / 4);
            result = GetSinTab(new FixedNumber(tabCount / 4) - r);
        }
        else if (r >= tabCount / 2 && r < 3 * tabCount / 4)    // PI ~ 3/4*PI
        {
            r -= new FixedNumber(tabCount / 2);
            result = -GetSinTab(r);
        }
        else if (r >= 3 * tabCount / 4 && r < tabCount)      // 3/4*PI ~ 2*PI
        {
            r = new FixedNumber(tabCount) - r;
            result = -GetSinTab(r);
        }

        return result;
    }
    public static FixedNumber Abs(FixedNumber ratio)
    {
        return FixedNumber.Abs(ratio);
    }
    public static FixedNumber Sqrt(FixedNumber r)
    {
        return FixedNumber.Sqrt(r);
    }

    public static FixedNumber Cos(FixedNumber r)
    {
        return Sin(r + PI / 2);
    }
    public static FixedNumber SinAngle(FixedNumber angle)
    {
        return Sin(angle / 180 * PI);
    }
    public static FixedNumber CosAngle(FixedNumber angle)
    {
        return Cos(angle / 180 * PI);
    }
}

总结

上面做的封装基本还算完善,可以看下代码具体怎么使用。
感谢大家的支持文章来源地址https://www.toymoban.com/news/detail-828772.html

到了这里,关于定点数,定点数二维向量,定点数三维向量,定点数数学类的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Unity --- 三维数学 --- 欧拉角与四元数

      1.Transfrom中的Rotation中的x,y,z三个值就是对应着三个方向上的欧拉角 2.注意物体沿Y轴方向旋转时,是沿世界坐标系的Y轴旋转,而不是沿自身的Y轴旋转 3.一个物体三个方向上的欧拉角是用一个Vector3三维向量对象来表示的 --- (x,y,z)分别对应三个方向上的欧拉角 1.接下来开始

    2024年01月15日
    浏览(42)
  • 每周学点数学 1:数学建模计划篇

    用GPT3.5生成了一段数学建模学习的计划,我准备在视觉学习的同时,穿插一些数学理论方面的学习,以下是近三个月的计划。 7月2日-7月8日:了解数学建模的基本概念和方法,阅读相关教材和论文,了解数学建模的应用领域和实际问题。 7月9日-7月15日:学习线性代数和概率论

    2024年02月12日
    浏览(27)
  • 三维向量的夹角

    计算三维坐标组成的夹角 参考:[三维向量夹角在线计算](https://www.23bei.com/tool/300.html) 公式: 三维向量夹角的计算公式如下: 假设两个三维向量分别为:a=(x1,y1,z1),b=(x2,y2,z2)。 向量a的模:|a|=√(x1 2+y1 2+z1^2)。 向量b的模:|b|=√(x2 2+y2 2+z2^2)。 两个向量的点乘:a·b=(x1x2+y1y2+z

    2024年02月11日
    浏览(34)
  • 【基础】什么是三维向量

    接前文什么是视锥体,三维向量的知识点用于补充3D软件的使用知识。 具有 方向 和 长度 的线段叫做 有向线段 。 有向线段 的 长度 表示向量的 大小 ,向量的大小即是线段的长度。 向量的 大小 也被称为向量的 模 。 二维向量,又称平面向量,是在二维平面内既有方向又有

    2024年02月13日
    浏览(30)
  • 核密度估计(二维、三维)

    核密度估计是通过平滑的峰值函数来拟合样本数据,利用连续的密度曲线描述随机变量的分布形态,具有稳健性强、模型依赖性弱的特性。现在已经被广泛的应用到动态演进分析当中,核密度估计通常有二维、三维表现形式,如下图: (上述图片分别取自于陈明华, 刘文斐

    2024年02月16日
    浏览(33)
  • MATLAB二维与三维绘图实验

    本文MATLAB源码,下载后直接打开运行即可[点击跳转下载]-附实验报告 https://download.csdn.net/download/Coin_Collecter/88740747 掌握图形对象属性的基本操作。 掌握利用图形对象进行绘图操作的方法。 利用图形对象绘制曲线,要求先利用默认属性绘制曲线,然后通过图形句柄操作将曲线

    2024年01月17日
    浏览(49)
  • 二维坐标和三维坐标相互转换

    原理参考世界坐标系、相机坐标系、图像坐标系、像素坐标系之间的转换 我的需求是将二维点转换成三维点,旋转三维点,再转换为二维点,此处的旋转跟相机成像的旋转矩阵又没有关系。 假定像素坐标为(u,v),处理的输入数据是像素坐标,图像坐标为(x,y),相机坐标为(Xc

    2024年02月15日
    浏览(42)
  • 三维点云转换为二维图像

    目的:将 三维点云 转换为 二维图像 作用: a.给点云赋予彩色信息,增强点云所表达物体或对象的辨识度; b.将三维点云中绘制的目标物体通过映射关系绘制到二维图像中,这个工作在点云标注邻域被广泛使用; c.可以根据点云中绘制的结果提取二维图像中对应的物体 确定要

    2024年02月10日
    浏览(39)
  • Matlab把二维矩阵画成三维图像

    上面的速度文件是一列数据,在matlab中可以认为是向量,数据量为10000*5000,所以才能被设置为5000*10000的矩阵。 这样画出来的图像水平两轴为x:1,10000;y:1,5000。 垂向上的数值则是矩阵对应的速度值。 因为数据量太大,电脑很卡就不放图片了,你可以用C语言或者其他的什

    2024年02月12日
    浏览(36)
  • 【LeetCode: 剑指 Offer 60. n个骰子的点数 | 数学+ 暴力递归=>记忆化搜索=>动态规划】

    🍎作者简介:硕风和炜,CSDN-Java领域新星创作者🏆,保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享💎💎💎 🍎座右铭:人生如棋,我愿为卒,行动虽慢,可谁曾见我后退一步?🎯🎯🎯 剑指 Offer 60. n个骰子的点

    2023年04月19日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包