PG0003.Question01

[jack81722]

Introduction

實作Unity的Vector2...

Answer

答案

需要一點數學知識...

public struct Vector2
{
    /// <summary>
    /// The tolerance of the float value
    /// </summary>
    private const float kEpsilon = 1E-05f;

    #region -- Constant Vectors --
    public static readonly Vector2 Zero = new Vector2(0, 0);
    public static readonly Vector2 One = new Vector2(1, 1);
    public static readonly Vector2 Left = new Vector2(-1, 0);
    public static readonly Vector2 Right = new Vector2(1, 0);
    public static readonly Vector2 Up = new Vector2(0, 1);
    public static readonly Vector2 Down = new Vector2(0, -1);
    #endregion

    /// <summary>
    /// x-axis
    /// </summary>
    public float x;

    /// <summary>
    /// y-axis
    /// </summary>
    public float y;

    /// <summary>
    /// Length of vector
    /// </summary>
    public float magnitude
    {
        get
        {
            return (float)Math.Sqrt(x * x + y * y);
        }
    }

    #region -- Constructor --
    /// <summary>
    /// Constructor for newing vector
    /// </summary>
    /// <param name="x">init x-axis</param>
    /// <param name="y">init y-axis</param>
    public Vector2(float x, float y)
    {
        this.x = x;
        this.y = y;
    }
    #endregion

    /// <summary>
    /// Normalize current vector
    /// </summary>
    public void Normalize()
    {
        float len = magnitude;
        if (len < kEpsilon)
        {
            x = 0;
            y = 0;
        }
        else
        {
            x /= len;
            y /= len;
        }
    }

    /// <summary>
    /// Calculate current length of vector
    /// </summary>
    /// <returns>length of vector</returns>
    public float Magnitude()
    {
        return (float)Math.Sqrt(x * x + y * y);
    }

    /// <summary>
    /// Revert current vector
    /// </summary>
    public void Negative()
    {
        x = -x;
        y = -y;
    }

    /// <summary>
    /// Add other vector
    /// </summary>
    public void Add(Vector2 v)
    {
        x += v.x;
        y += v.y;
    }

    /// <summary>
    /// Subtract other vector
    /// </summary>
    public void Subtract(Vector2 v)
    {
        x -= v.x;
        y -= v.y;
    }

    #region -- Static Methods --
    /// <summary>
    /// Normalize specific vector
    /// </summary>
    /// <param name="v">the specific vector to normalize</param>
    /// <returns>Normalized vector</returns>
    public static Vector2 Normalize(Vector2 v)
    {
            v.Normalize();
        return v;
    }

    /// <summary>
    /// Calculate distence between vectors
    /// </summary>
    /// <param name="from">the start vector</param>
    /// <param name="to">the end vector</param>
    /// <returns>Distance between from and to vectors</returns>
    public static float Distance(Vector2 from, Vector2 to)
    {
        float xx = from.x - to.x;
        float yy = from.y - to.y;
        return (float)Math.Sqrt(xx * xx + yy * yy);
    }
    #endregion
}

[A24575255]

JIA（程式新手）

我的答案

public float magnitude
{
    get => (float)Math.Sqrt(x * x + y * y);
}
public Vector2(float x, float y)
{
    this.x = x;
    this.y = y;
}
public void Normalize()
{
    float length = magnitude;
    if (length > 0)
    {
        x /= length;
        y /= length;
    }
}
public float Magnitude()
{
    return magnitude;
}
public void Negative()
{
    x *= -1;
    y *= -1;
}
public void Add(Vector2 v)
{
    x += v.x;
    y += v.y;
}
public void Subtract(Vector2 v)
{
    x -= v.x;
    y -= v.y;
}
public static Vector2 Normalize(Vector2 v)
{
    v.Normalize();
    return v;
}
public static float Distance(Vector2 from, Vector2 to)
{
    return new Vector2(to.x - from.x, to.y - from.y).magnitude;
}

看到題目直接滿頭問號XD

[louise-bwsx]

小4 ( 程式 )

		public struct Vector2
        {
            private const float kEpsilon = 1E-05f;
            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);
            public float x;
            public float y;
            public float magnitude { get; }

            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
                magnitude = (float)Math.Sqrt(x * x + y * y);
            }

            public void Normalize()
            {
                float len = (float)Math.Sqrt(x * x + y * y);
                if (len > kEpsilon)
                {
                    x /= len;
                    y /= len;
                }
                else
                {
                    x = 0;
                    y = 0;
                }
            }

            public float Magnitude()
            {
                return (float)Math.Sqrt(x * x + y * y);
            }

            public void Negative()
            {
                x *= -1;
                y *= -1;
            }

            public void Add(Vector2 v)
            {
                x += v.x;
                y += v.y;
            }

            public void Subtract(Vector2 v)
            {
                x -= v.x;
                y -= v.y;
            }

            public static Vector2 Normalize(Vector2 v)
            {
                float len = (float)Math.Sqrt(v.x * v.x + v.y * v.y);
                if (len > kEpsilon)
                {
                    v.x /= len;
                    v.y /= len;
                }
                else
                {
                    v.x = 0;
                    v.y = 0;
                }
                return v;
            }

            public static float Distance(Vector2 from, Vector2 to)
            {
                float newX = from.x - to.x;
                float newY = from.y - to.y;
                return new Vector2(newX, newY).magnitude;
            }
        }

扯 Distance竟然被我矇對
完全沒搞清楚 magnitude 跟 normalize直接抄影片的範例
我完全沒碰過struct只知道跟class很像 然後是reference type 還是 value type 反正跟 class相反
只知道vector 是用struct來做的 還不知道哪裡會用到struct

[jack81722]

出題目的時候我也想很久
有時在寫演算法的時候，如果資料有兩個以上的資訊
就有可能用struct包裝在一起處理
這裡除了介紹struct，更多是讓你們可以比較熟悉field, property, method的使用
順便了解一下Unity的一些結構用法

[OLDShaw1022]

老蕭OLDShaw（程式）

我的答案

public class Question1
    {
        public struct Vector2
        {
            /// <summary>
            /// The tolerance of the float value
            /// </summary>
            private const float kEpsilon = 1E-05f;

            #region -- Constant Vectors --
            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);
            #endregion

            /// <summary>
            /// x-axis
            /// </summary>
            public float x;

            /// <summary>
            /// y-axis
            /// </summary>
            public float y;

            /// <summary>
            /// Length of vector
            /// </summary>
            public float magnitude { get { return Magnitude(); }}

            #region -- Constructor --
            /// <summary>
            /// Constructor for newing vector
            /// </summary>
            /// <param name="x">init x-axis</param>
            /// <param name="y">init y-axis</param>
            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
            }
            #endregion

            /// <summary>
            /// Normalize current vector
            /// </summary>
            public void Normalize()
            {
                float currentMagnitude = magnitude;
                x /= currentMagnitude;
                y /= currentMagnitude;
            }

            /// <summary>
            /// Calculate current length of vector
            /// </summary>
            /// <returns>length of vector</returns>
            public float Magnitude()
            {                
                return (float)Math.Sqrt(Math.Pow(x, 2) + Math.Pow(y, 2));
            }

            /// <summary>
            /// Revert current vector
            /// </summary>
            public void Negative()
            {
                x = -x;
                y = -y;
            }

            /// <summary>
            /// Add other vector
            /// </summary>
            public void Add(Vector2 v)
            {
                x += v.x;
                y += v.y;
            }

            /// <summary>
            /// Subtract other vector
            /// </summary>
            public void Subtract(Vector2 v)
            {
                x -= v.x;
                y -= v.y;
            }

            #region -- Static Methods --
            /// <summary>
            /// Normalize specific vector
            /// </summary>
            /// <param name="v">the specific vector to normalize</param>
            /// <returns>Normalized vector</returns>
            public static Vector2 Normalize(Vector2 v)
            {
                float targetMagnitude = (float)Math.Sqrt(Math.Pow(v.x, 2) + Math.Pow(v.y, 2));
                v.x /= targetMagnitude;
                v.y /= targetMagnitude;
                return v;
            }

            /// <summary>
            /// Calculate distence between vectors
            /// </summary>
            /// <param name="from">the start vector</param>
            /// <param name="to">the end vector</param>
            /// <returns>Distance between from and to vectors</returns>
            public static float Distance(Vector2 from, Vector2 to)
            {
                return (float)Math.Sqrt(Math.Pow(from.x - to.x, 2) + Math.Pow(from.y - to.y, 2));
            }
            #endregion
        }
    }

測試截圖

不確定需不需要設一個Bool來去防止Magnitude或是Normalize重複進行無謂的計算。

[jack81722]

確實有這種寫法
我可能會用dirty pattern去設定一個flag叫做isDirty
並且把x, y變為property，每次設定時把isDirty設為true
同樣的，magnitude跟normalized也建立一個私有欄位跟屬性
get的時候判斷isDirty來決定重新計算還是回傳已經算好的結果

需要注意的只有nested struct的問題

[s32436515]

肉鬆（程式 / 音樂）

我的答案

　　public struct Vector2
        {
            public float magnitude
            {
                get
                {
                    return (float)Math.Sqrt((x * x) + (y * y));
                }
            }

            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
            }

            public void Normalize()
            {
                float len = magnitude;
                if (len < kEpsilon)
                {
                    x = 0;
                    y = 0;
                }
                else if (len >= kEpsilon)
                {
                    x /= len;
                    y /= len;
                }
            }

            public float Magnitude()
            {
                return (float)Math.Sqrt((x * x) + (y * y));
            }

            public void Negative()
            {
                x *= -1;
                y *= -1;
            }

            public void Add(Vector2 v)
            {
                this.x += v.x;
                this.y += v.y;
            }

            public void Subtract(Vector2 v)
            {
                this.x -= v.x;
                this.y -= v.y;
            }

            public static Vector2 Normalize(Vector2 v)
            {
                v.Normalize();
                return v;
            }

            public static float Distance(Vector2 from, Vector2 to)
            {
                float newX = from.x - to.x;
                float newY = from.y - to.y;
                return (float)Math.Sqrt((newX * newX) + (newY * newY));
            }
        }

課程回饋

這次突然跳躍到數學了 一開始真的不知道從哪裡下手 Orzz
Normalize的部分實在想不通qq 所以只有這部分是參考老師的寫法
另外希望課程各部分的舉例可以深入一點(或多說一點 ?) 怕會聽不懂或理解錯誤 ><
總之這次還是感謝勞師的課程🙏🙏

[jack81722]

正規化就是把向量轉為單位向量的過程
而所謂的單位向量，是指說長度只有１的向量，
為什麼要變成長度１的理由很簡單，當你希望保留一個向量的“方向”卻又希望他變為一個指定“長度”的話，
那麼就可以將向量轉為單位向量（方向）再乘上你希望的長度值（長度）

[s32436515]

正規化就是把向量轉為單位向量的過程 而所謂的單位向量，是指說長度只有１的向量， 為什麼要變成長度１的理由很簡單，當你希望保留一個向量的“方向”卻又希望他變為一個指定“長度”的話， 那麼就可以將向量轉為單位向量（方向）再乘上你希望的長度值（長度）

感謝老師特別講解！🙏
在當天做完後有去翻閱國外的文章大概能理解，但果然還是用中文說過一遍會最速吸收啊！><

[YouSyuan]

Syuan(新人/企劃/程式/美術)

我的答案

        public struct Vector2
        {
            private const float kEpsilon = 1E-05f;

            #region -- Constant Vectors --
            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);
            #endregion

            public float x;
            public float y;

            public float magnitude { get { return Magnitude(); } }

            #region -- Constructor --
            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
            }
            #endregion

            public void Normalize()
            { 
                float len = magnitude;
                if (len > kEpsilon)
                { x /= len; y /= len; }
                else
                { x = 0; y = 0; }
            }

            public float Magnitude()
            {
                return (float)Math.Sqrt(x * x + y * y);
            }

            public void Negative()
            {
                x = -x;y = -y;
            }

            public void Add(Vector2 v)
            {
                x += v.x;y += v.y;
            }

            public void Subtract(Vector2 v)
            {
                x -= v.x; y -= v.y;
            }

            #region -- Static Methods --
            public static Vector2 Normalize(Vector2 v)
            {
                v.Normalize();
                return v;
            }
            public static float Distance(Vector2 from, Vector2 to)
            {
                float X = from.x - to.x;float Y = from.y - to.y;
                return (float)Math.Sqrt(X*X+Y*Y);
            }
            #endregion
        }

[crazyjimmy0623]

吉米（不知道要學什麼但是喜歡創作的新人）

答案在這

   /// <summary>
            /// The tolerance of the float value
            /// </summary>
            private const float kEpsilon = 1E-05f;

            #region -- Constant Vectors --
            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);
            #endregion

            /// <summary>
            /// x-axis
            /// </summary>
            public float x;

            /// <summary>
            /// y-axis
            /// </summary>
            public float y;

            /// <summary>
            /// Length of vector
            /// </summary>
            public float magnitude { get => MathF.Sqrt(x * x + y * y); }

            #region -- Constructor --
            /// <summary>
            /// Constructor for newing vector
            /// </summary>
            /// <param name="x">init x-axis</param>
            /// <param name="y">init y-axis</param>
            public Vector2(float x, float y)
            {
                this.x = x; 
                this.y = y;
            }
            #endregion

            /// <summary>
            /// Normalize current vector
            /// </summary>
            public void Normalize()
            {
                float len = (float)MathF.Sqrt(x*x + y*y);

                if(len > kEpsilon)
                {
                    x /= len;
                    y /= len;
                }
                else
                {
                    x = 0;
                    y = 0;
                }
            }

            /// <summary>
            /// Calculate current length of vector
            /// </summary>
            /// <returns>length of vector</returns>
            public float Magnitude()
            {
                return MathF.Sqrt(x* x + y * y);
            }

            /// <summary>
            /// Revert current vector
            /// </summary>
            public void Negative()
            {
                x *= -1;
                y *= -1;
            }

            /// <summary>
            /// Add other vector
            /// </summary>
            public void Add(Vector2 v)
            {
                x += v.x;
                y += v.y;
            }

            /// <summary>
            /// Subtract other vector
            /// </summary>
            public void Subtract(Vector2 v)
            {
                x -= v.x;
                y -= v.y;
            }

            #region -- Static Methods --
            /// <summary>
            /// Normalize specific vector
            /// </summary>
            /// <param name="v">the specific vector to normalize</param>
            /// <returns>Normalized vector</returns>
            public static Vector2 Normalize(Vector2 v)
            {
                 v.Normalize();
                 return v;
            }

            /// <summary>
            /// Calculate distence between vectors
            /// </summary>
            /// <param name="from">the start vector</param>
            /// <param name="to">the end vector</param>
            /// <returns>Distance between from and to vectors</returns>
            public static float Distance(Vector2 from, Vector2 to)
            {
                float DistanceX = to.x - from.x;
                float DistanceY  = to.y - from.y;
                return (float)Math.Sqrt(DistanceX * DistanceX + DistanceY * DistanceY);
            }
            #endregion

哇勒，原本想說我應該都會，都有看過有概念，結果看到題目直接矇XD
連要寫在哪都不知道，只能先看老師的答案怎麼填，笑死
果然還是要實踐一次才能轉化腦中的知識
原來平常用的都是這樣寫出來的

[jack81722]

沒錯喔，而且magnitude跟normalize的計算用到了平方根的算法
所以有些人會說大量計算這兩樣會有效能問題也是因為這段程式碼
先把這兩者的計算結果儲存後再去處理會更好
有時候理解底層會對擴展跟開發有很大的幫助

[crazyjimmy0623]

了解 謝謝老師!
一開始寫遊戲也是沒什麼程式基礎就開始跟者學，導致現在可能有看過但也不知道原理跟一些專有名詞。
現在可以跟著老師從頭開始學
常常會有:原來是這樣啊 的情況XD
受益良多!

[tommyboys0107]

Cliff Lee CL (程式、專案管理)

我的答案

public struct Vector2
{
    /// <summary>
    /// The tolerance of the float value
    /// </summary>
    private const float kEpsilon = 1E-05f;

    #region -- Constant Vectors --
    public static readonly Vector2 Zero = new Vector2(0, 0);
    public static readonly Vector2 One = new Vector2(1, 1);
    public static readonly Vector2 Left = new Vector2(-1, 0);
    public static readonly Vector2 Right = new Vector2(1, 0);
    public static readonly Vector2 Up = new Vector2(0, 1);
    public static readonly Vector2 Down = new Vector2(0, -1);
    #endregion

    /// <summary>
    /// x-axis
    /// </summary>
    public float x;

    /// <summary>
    /// y-axis
    /// </summary>
    public float y;

    /// <summary>
    /// Length of vector
    /// </summary>
    public float magnitude { get; }

    #region -- Constructor --
    /// <summary>
    /// Constructor for newing vector
    /// </summary>
    /// <param name="x">init x-axis</param>
    /// <param name="y">init y-axis</param>
    public Vector2(float x, float y)
    {
        this.x = x;
        this.y = y;
        magnitude = MathF.Sqrt(x * x + y * y);
    }
    #endregion

    /// <summary>
    /// Normalize current vector
    /// </summary>
    public void Normalize()
    {
        x /= magnitude;
        y /= magnitude;
    }

    /// <summary>
    /// Calculate current length of vector
    /// </summary>
    /// <returns>length of vector</returns>
    public float Magnitude()
    {
        return magnitude;
    }

    /// <summary>
    /// Revert current vector
    /// </summary>
    public void Negative()
    {
        x = -x;
        y = -y;
    }

    /// <summary>
    /// Add other vector
    /// </summary>
    public void Add(Vector2 v)
    {
        x += v.x;
        y += v.y;
    }

    /// <summary>
    /// Subtract other vector
    /// </summary>
    public void Subtract(Vector2 v)
    {
        x -= v.x;
        y -= v.y;
    }

    #region -- Static Methods --
    /// <summary>
    /// Normalize specific vector
    /// </summary>
    /// <param name="v">the specific vector to normalize</param>
    /// <returns>Normalized vector</returns>
    public static Vector2 Normalize(Vector2 v)
    {
        v.Normalize();
        return v;
    }

    /// <summary>
    /// Calculate distence between vectors
    /// </summary>
    /// <param name="from">the start vector</param>
    /// <param name="to">the end vector</param>
    /// <returns>Distance between from and to vectors</returns>
    public static float Distance(Vector2 from, Vector2 to)
    {
        return (float)Math.Sqrt(Math.Pow(to.x - from.x, 2) + Math.Pow(to.y - from.y, 2));
    }
    #endregion
}

[ChiaBurn]

ChiaBurn(程式 | 企劃)

作業程式碼

{
    public struct Vector2
    {
        ...
        public float magnitude
        {
            get
            {
                return (float)Math.Sqrt(x * x + y * y);
            }
        }

        #region -- Constructor --
        public Vector2(float x, float y)
        {
            this.x = x;
            this.y = y;
        }
        #endregion
        
        public void Normalize()
        {
            var len = this.magnitude;
            if (len > kEpsilon)
            {
                x /= len;
                y /= len;
            }
            else
            {
                x = 0;
                y = 0;
            }
        }
        
        public float Magnitude()
        {
            return (float)Math.Sqrt(x * x + y * y);
        }
        
        public void Negative()
        {
            this.x *= -1;
            this.y *= -1;
        }
        
        public void Add(Vector2 v)
        {
            this.x += v.x;
            this.y += v.y;
        }
        
        public void Subtract(Vector2 v)
        {
            this.x -= v.x;
            this.y -= v.y;
        }

        #region -- Static Methods --
        
        public static Vector2 Normalize(Vector2 v)
        {
            var len = v.magnitude;
            if (len > kEpsilon)
            {
                return new Vector2(v.x / len, v.y / len);
            }
            else
            {
                return new Vector2(0, 0);
            }
        }
        
        public static float Distance(Vector2 from, Vector2 to)
        {
            var distanceX = to.x - from.x;
            var distanceY = to.y - from.y;
            return (float)Math.Sqrt(distanceX * distanceX + distanceY * distanceY);
        }
        
        #endregion
    }
}

程式碼測試結果

想法與反饋

1. 我原本static的Normalize方法想這樣寫：

public static Vector2 Normalize(Vector2 v)
{
    v.Normalize(); // 直接叫用前面寫好的方法
    return v;
}

雖然能通過測試，但想想覺得怪，因為作為使用者的話，我看到方法有return Vector2就會傾向認定這個方法只會幫我算出一個新的值、不會動到我原本的input。
想問問慣例上這個static的Normalize方法是不是應該只能單純利用input v算出新的的Normalized值，而不可以異動到input v本身的值呢?(這樣好像是叫「避免side effects」?)

2. 之前我一直把「欄位」與「屬性」當同一件事混在一起叫，原來兩者間有「是否有存取子」的差異，長知識了！

3. 平常都是使用Class、對struct真的超不熟！很謝謝老師把struct課程安排在前面。期待下半場的課程能學習到兩者間在性質與使用情境上的不同🤩

[jack81722]

你問了一個很好的問題
不過因為我還沒提到所以沒特別講
因為struct是pass by value的型別
所以他並不會像class一樣造成傳入值的修改
在這邊是可以這樣寫的

[XZKpo666]

我的答案

public class Question1 { public struct Vector2 { ///

/// The tolerance of the float value ///

private const float kEpsilon = 1E-05f;

        #region -- Constant Vectors --
        public static readonly Vector2 Zero = new Vector2(0, 0);
        public static readonly Vector2 One = new Vector2(1, 1);
        public static readonly Vector2 Left = new Vector2(-1, 0);
        public static readonly Vector2 Right = new Vector2(1, 0);
        public static readonly Vector2 Up = new Vector2(0, 1);
        public static readonly Vector2 Down = new Vector2(0, -1);
        #endregion

        /// <summary>
        /// x-axis
        /// </summary>
        public float x;

        /// <summary>
        /// y-axis
        /// </summary>
        public float y;

        /// <summary>
        /// Length of vector
        /// </summary>
        public float magnitude 
        { 
            get
            {
                return (float)Math.Sqrt( x * x + y * y);
            } 
        }

        #region -- Constructor --
        /// <summary>
        /// Constructor for newing vector
        /// </summary>
        /// <param name="x">init x-axis</param>
        /// <param name="y">init y-axis</param>
        public Vector2(float x, float y)
        {
            this.x = x;
            this.y = y;
        }
        #endregion

        /// <summary>
        /// Normalize current vector
        /// </summary>
        public void Normalize()
        {
            float length = magnitude;
            if (length >= kEpsilon)
            {
                x /= length;
                y /= length;
            }
            else
            {
                x = 0;
                y = 0;
            }
        }

        /// <summary>
        /// Calculate current length of vector
        /// </summary>
        /// <returns>length of vector</returns>
        public float Magnitude()
        {
            return (float)Math.Sqrt(x * x + y * y);
        }

        /// <summary>
        /// Revert current vector
        /// </summary>
        public void Negative()
        {
            x = -x;
            y = -y;
        }

        /// <summary>
        /// Add other vector
        /// </summary>
        public void Add(Vector2 v)
        {
            x += v.x;
            y += v.y;
        }

        /// <summary>
        /// Subtract other vector
        /// </summary>
        public void Subtract(Vector2 v)
        {
            x -= v.x;
            y -= v.y;
        }

        #region -- Static Methods --
        /// <summary>
        /// Normalize specific vector
        /// </summary>
        /// <param name="v">the specific vector to normalize</param>
        /// <returns>Normalized vector</returns>
        public static Vector2 Normalize(Vector2 v)
        {
             v.Normalize();
            return v;
        }

        /// <summary>
        /// Calculate distence between vectors
        /// </summary>
        /// <param name="from">the start vector</param>
        /// <param name="to">the end vector</param>
        /// <returns>Distance between from and to vectors</returns>
        public static float Distance(Vector2 from, Vector2 to)
        {
            float X = from.x - to.x;
            float Y = from.y - to.y;
            return (float)Math.Sqrt(X * X + Y * Y);
        }
        #endregion
    }
}

我的感想

太多數學了 太多英文了 幹

[BoLingCan]

罐頭（程式）

我的答案ヾ(•ω•`)o

using System;

namespace PG0003.Questions
{
    public class Question1
    {
        public struct Vector2
        {
            /// <summary>
            /// The tolerance of the float value
            /// </summary>
            private const float kEpsilon = 1E-05f;

            #region -- Constant Vectors --

            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);

            #endregion

            /// <summary>
            /// x-axis
            /// </summary>
            public float x;

            /// <summary>
            /// y-axis
            /// </summary>
            public float y;

            /// <summary>
            /// Length of vector
            /// </summary>
            public float magnitude => Magnitude();

            #region -- Constructor --

            /// <summary>
            /// Constructor for newing vector
            /// </summary>
            /// <param name="x">init x-axis</param>
            /// <param name="y">init y-axis</param>
            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
            }

            #endregion

            /// <summary>
            /// Normalize current vector
            /// </summary>
            public void Normalize()
            {
                float len = magnitude;
                if (len < kEpsilon)
                {
                    x = 0;
                    y = 0;
                }
                else
                {
                    x /= len;
                    y /= len;
                }
            }

            /// <summary>
            /// Calculate current length of vector
            /// </summary>
            /// <returns>length of vector</returns>
            public float Magnitude()
            {
                return (float)Math.Sqrt(x * x + y * y);
            }

            /// <summary>
            /// Revert current vector
            /// </summary>
            public void Negative()
            {
                x = -x;
                y = -y;
            }

            /// <summary>
            /// Add other vector
            /// </summary>
            public void Add(Vector2 v)
            {
                x += v.x;
                y += v.y;
            }

            /// <summary>
            /// Subtract other vector
            /// </summary>
            public void Subtract(Vector2 v)
            {
                x -= v.x;
                y -= v.y;
            }

            #region -- Static Methods --

            /// <summary>
            /// Normalize specific vector
            /// </summary>
            /// <param name="v">the specific vector to normalize</param>
            /// <returns>Normalized vector</returns>
            public static Vector2 Normalize(Vector2 v)
            {
                v.Normalize();
                return v;
            }

            /// <summary>
            /// Calculate distence between vectors
            /// </summary>
            /// <param name="from">the start vector</param>
            /// <param name="to">the end vector</param>
            /// <returns>Distance between from and to vectors</returns>
            public static float Distance(Vector2 from, Vector2 to)
            {
                float xDiff = to.x - from.x;
                float yDiff = to.y - from.y;
                return (float)Math.Sqrt((xDiff * xDiff) + (yDiff * yDiff));
            }

            #endregion
        }
    }
}

抱歉，這次的作業比較晚交~突然就開始進入到偶的未知領域了，花了不少功夫理解，希望最終的作業有達到老師的期望。有勞老師過目了，感謝（；´д｀）ゞ

[ISnoweve]

Snoweve (程式)

我的答案

using System;

namespace PG0003.Questions
{
    public class Question1
    {
        public struct Vector2
        {
            /// <summary>
            /// The tolerance of the float value
            /// </summary>
            private const float kEpsilon = 1E-05f;

            #region -- Constant Vectors --
            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);
            #endregion

            /// <summary>
            /// x-axis
            /// </summary>
            public float x;

            /// <summary>
            /// y-axis
            /// </summary>
            public float y;

            /// <summary>
            /// Length of vector
            /// </summary>
            public float magnitude
            {
                get => Magnitude();
            }

            #region -- Constructor --
            /// <summary>
            /// Constructor for newing vector
            /// </summary>
            /// <param name="x">init x-axis</param>
            /// <param name="y">init y-axis</param>
            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
            }
            #endregion

            /// <summary>
            /// Normalize current vector
            /// </summary>
            public void Normalize()
            {
                float lenMagnitude = magnitude;
                if (lenMagnitude < kEpsilon)
                {
                    x = 0;
                    y = 0;
                }
                else if (lenMagnitude >= kEpsilon)
                {
                    x /= lenMagnitude;
                    y /= lenMagnitude;
                }
            }

            /// <summary>
            /// Calculate current length of vector
            /// </summary>
            /// <returns>length of vector</returns>
            public float Magnitude()
            {
                return (float)Math.Sqrt(Math.Pow(x, 2) + Math.Pow(y, 2));
            }

            /// <summary>
            /// Revert current vector
            /// </summary>
            public void Negative()
            {
                x = -x;
                y = -y;
            }

            /// <summary>
            /// Add other vector
            /// </summary>
            public void Add(Vector2 v)
            {
                x += v.x;
                y += v.y;
            }

            /// <summary>
            /// Subtract other vector
            /// </summary>
            public void Subtract(Vector2 v)
            {
                x -= v.x;
                y -= v.y;
            }

            #region -- Static Methods --
            /// <summary>
            /// Normalize specific vector
            /// </summary>
            /// <param name="v">the specific vector to normalize</param>
            /// <returns>Normalized vector</returns>
            public static Vector2 Normalize(Vector2 v)
            {
                v.Normalize();
                return v;
            }

            /// <summary>
            /// Calculate distence between vectors
            /// </summary>
            /// <param name="from">the start vector</param>
            /// <param name="to">the end vector</param>
            /// <returns>Distance between from and to vectors</returns>
            public static float Distance(Vector2 from, Vector2 to)
            {
                float xdiff = from.x - to.x;
                float ydiff = from.y - to.y;
                return (float)Math.Sqrt(Math.Pow(xdiff, 2) + Math.Pow(ydiff, 2));
            }
            #endregion
        }
    }
}

![image]

<<反饋>>
辛苦老師了
這次的作業花比較多時間在理解Func上的註解，像是Magnitude和Normalize，平常寫的時候不會用到，需要上網查那些到底是做甚麼用的，Distance之前寫距離判斷追擊有用過，所以蠻快就寫出來了

[vre343434]

七七(程式)

我的答案

public class Question1
    {
        public struct Vector2
        {
            /// <summary>
            /// The tolerance of the float value
            /// </summary>
            private const float kEpsilon = 1E-05f;

            #region -- Constant Vectors --
            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);
            #endregion

            /// <summary>
            /// x-axis
            /// </summary>
            public float x;

            /// <summary>
            /// y-axis
            /// </summary>
            public float y;

            /// <summary>
            /// Length of vector
            /// </summary>
            public float magnitude
            {
                get { return (float)Math.Sqrt(x * x + y * y); }
            }

            #region -- Constructor --
            /// <summary>
            /// Constructor for newing vector
            /// </summary>
            /// <param name="x">init x-axis</param>
            /// <param name="y">init y-axis</param>
            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
            }
            #endregion

            /// <summary>
            /// Normalize current vector
            /// </summary>
            public void Normalize()
            {
                // x = x / this.magnitude;
                // y = y / this.magnitude;  修正前
                //                          修正後

                // if (magnitude < kEpsilon) 又錯!?
                // {
                //     x = 0;
                //     y = 0;
                // }
                // else
                // {
                //     x = x / magnitude;
                //     y = y / magnitude;
                // }

                float len = magnitude; //看老師的修改，好像是magnitude小數點每次計算的誤差導致錯誤了
                if (len < kEpsilon) //確實這樣修改不用算那麼多次，而且測試才會過
                {
                    x = 0;
                    y = 0;
                }
                else
                {
                    x /= len;
                    y /= len;
                }
            }

            /// <summary>
            /// Calculate current length of vector
            /// </summary>
            /// <returns>length of vector</returns>
            public float Magnitude()
            {
                return (float)Math.Sqrt(x * x + y * y);
            }

            /// <summary>
            /// Revert current vector
            /// </summary>
            public void Negative()
            {
                x = -x;
                y = -y;
            }

            /// <summary>
            /// Add other vector
            /// </summary>
            public void Add(Vector2 v)
            {
                x += v.x;
                y += v.y;
            }

            /// <summary>
            /// Subtract other vector
            /// </summary>
            public void Subtract(Vector2 v)
            {
                x -= v.x;
                y -= v.y;
            }

            #region -- Static Methods --
            /// <summary>
            /// Normalize specific vector
            /// </summary>
            /// <param name="v">the specific vector to normalize</param>
            /// <returns>Normalized vector</returns>
            public static Vector2 Normalize(Vector2 v)
            {
                float magnitude = (float)Math.Sqrt(v.x * v.x + v.y * v.y);
                return new Vector2(v.x / magnitude, v.y / magnitude);
            }

            /// <summary>
            /// Calculate distence between vectors
            /// </summary>
            /// <param name="from">the start vector</param>
            /// <param name="to">the end vector</param>
            /// <returns>Distance between from and to vectors</returns>
            public static float Distance(Vector2 from, Vector2 to)
            {
                return (float)
                    Math.Sqrt((Math.Pow(from.x - to.x, 2.0)) + Math.Pow(from.y - to.y, 2.0));
            }
            #endregion
        }
    }

٩(๑•̀ω•́๑)۶

[jack81722]

（っ^ｗ^）っ

[TWEdward]

TWEdward(新人/程式/企劃)

我的答案

public struct Vector2
        {
            /// <summary>
            /// The tolerance of the float value
            /// </summary>
            private const float kEpsilon = 1E-05f;

            #region -- Constant Vectors --
            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);
            #endregion

            /// <summary>
            /// x-axis
            /// </summary>
            public float x;

            /// <summary>
            /// y-axis
            /// </summary>
            public float y;

            /// <summary>
            /// Length of vector
            /// </summary>
            public float magnitude { get; }

            #region -- Constructor --
            /// <summary>
            /// Constructor for newing vector
            /// </summary>
            /// <param name="x">init x-axis</param>
            /// <param name="y">init y-axis</param>
            public Vector2(float x, float y)
            {
               // throw new NotImplementedException();

                this.x = x;
                this.y = y;
                magnitude= (float)Math.Sqrt(x * x + y * y);
            }
            #endregion

            /// <summary>
            /// Normalize current vector
            /// </summary>
            public void Normalize()
            {
                // throw new NotImplementedException();

                float length = Magnitude();
                if(length>0)
                {
                    x /= length;
                    y /= length;
                }
            }

            /// <summary>
            /// Calculate current length of vector
            /// </summary>
            /// <returns>length of vector</returns>
            public float Magnitude()
            {
               // throw new NotImplementedException();

                return (float)Math.Sqrt(x*x + y*y);
            }

            /// <summary>
            /// Revert current vector
            /// </summary>
            public void Negative()
            {
                // throw new NotImplementedException();

                x = -x;
                y = -y;
            }

            /// <summary>
            /// Add other vector
            /// </summary>
            public void Add(Vector2 v)
            {
               // throw new NotImplementedException();

                x += v.x;
                y += v.y;
            }

            /// <summary>
            /// Subtract other vector
            /// </summary>
            public void Subtract(Vector2 v)
            {
               // throw new NotImplementedException();

                x -= v.x;
                y -= v.y;
            }

            #region -- Static Methods --
            /// <summary>
            /// Normalize specific vector
            /// </summary>
            /// <param name="v">the specific vector to normalize</param>
            /// <returns>Normalized vector</returns>
            public static Vector2 Normalize(Vector2 v)
            {
               // throw new NotImplementedException();

                float length=v.Magnitude();
                return new Vector2(v.x/length, v.y/length);
            }

            /// <summary>
            /// Calculate distence between vectors
            /// </summary>
            /// <param name="from">the start vector</param>
            /// <param name="to">the end vector</param>
            /// <returns>Distance between from and to vectors</returns>
            public static float Distance(Vector2 from, Vector2 to)
            {
               // throw new NotImplementedException();

                float dx=to.x-from.x;
                float dy=to.y-from.y;
                return (float)Math.Sqrt(dx*dx+dy*dy);
            }
            #endregion
        }

我解題的心得感想

這次的題目跟數學的向量有關，而我數學已經還給學校老師了(汗)，因此我就花了些時間，上網查找有關向量的數學知識，以及研究怎麼實作向量計算的程式碼寫法，也讓我越來越體會到要掌握程式軟工這個專長技能，相關的數學知識跟英文名詞多少也要知道。謝謝老師出的這一題有讓我認識到向量程式碼的實作寫法，也把還給學校的數學重新複習一遍(汗)><"

[jack81722]

程式是個工具，說現實一點，工具本身沒有太多價值
最多的價值體現在其他領域的domain knowhow
也因此公司所需要的人才通常是跨領域人才
遊戲本身更是多個領域的複合（音樂、物理、數學等）

[SoonYu97]

小鲨 (程式)

答案

public class Question1
{
    public struct Vector2
    {
        /// <summary>
        /// The tolerance of the float value
        /// </summary>
        private const float kEpsilon = 1E-05f;

        #region -- Constant Vectors --
        public static readonly Vector2 Zero = new Vector2(0, 0);
        public static readonly Vector2 One = new Vector2(1, 1);
        public static readonly Vector2 Left = new Vector2(-1, 0);
        public static readonly Vector2 Right = new Vector2(1, 0);
        public static readonly Vector2 Up = new Vector2(0, 1);
        public static readonly Vector2 Down = new Vector2(0, -1);
        #endregion

        /// <summary>
        /// x-axis
        /// </summary>
        public float x;

        /// <summary>
        /// y-axis
        /// </summary>
        public float y;

        /// <summary>
        /// Length of vector
        /// </summary>
        public float magnitude { get; }

        #region -- Constructor --
        /// <summary>
        /// Constructor for newing vector
        /// </summary>
        /// <param name="x">init x-axis</param>
        /// <param name="y">init y-axis</param>
        public Vector2(float x, float y)
        {
            this.x = x;
            this.y = y;
            magnitude = (float)Math.Sqrt(x * x + y * y);
        }
        #endregion

        /// <summary>
        /// Normalize current vector
        /// </summary>
        public void Normalize()
        {
            if (magnitude < kEpsilon)
            {
                x = 0;
                y = 0;
            }
            else
            {
                x = x / magnitude;
                y = y / magnitude;
            }
        }

        /// <summary>
        /// Calculate current length of vector
        /// </summary>
        /// <returns>length of vector</returns>
        public float Magnitude()
        {
            return magnitude;
        }

        /// <summary>
        /// Revert current vector
        /// </summary>
        public void Negative()
        {
            x = -x;
            y = -y;
        }

        /// <summary>
        /// Add other vector
        /// </summary>
        public void Add(Vector2 v)
        {
            x += v.x;
            y += v.y;
        }

        /// <summary>
        /// Subtract other vector
        /// </summary>
        public void Subtract(Vector2 v)
        {
            x -= v.x;
            y -= v.y;
        }

        #region -- Static Methods --
        /// <summary>
        /// Normalize specific vector
        /// </summary>
        /// <param name="v">the specific vector to normalize</param>
        /// <returns>Normalized vector</returns>
        public static Vector2 Normalize(Vector2 v)
        {
            if (v.magnitude < kEpsilon)
            {
                return Vector2.Zero;
            }
            return new Vector2(v.x / v.magnitude, v.y / v.magnitude);
        }

        /// <summary>
        /// Calculate distence between vectors
        /// </summary>
        /// <param name="from">the start vector</param>
        /// <param name="to">the end vector</param>
        /// <returns>Distance between from and to vectors</returns>
        public static float Distance(Vector2 from, Vector2 to)
        {
            return (float)Math.Sqrt(Math.Pow(to.x - from.x, 2) + Math.Pow(to.y - from.y, 2));
        }
        #endregion
    }
}

[jefflin0424]

肥羊(程式)

我的答案

public class Question1
    {
        public struct Vector2
        {
            /// <summary>
            /// The tolerance of the float value
            /// </summary>
            private const float kEpsilon = 1E-05f;

            #region -- Constant Vectors --
            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);
            #endregion

            /// <summary>
            /// x-axis
            /// </summary>
            public float x;

            /// <summary>
            /// y-axis
            /// </summary>
            public float y;

            /// <summary>
            /// Length of vector
            /// </summary>
            public float magnitude //返回向量长度为 (x*x+y*y) 的平方根
            {
                get
                {
                    return (float)Math.Sqrt(x * x + y * y);
                }
            }

            #region -- Constructor --
            /// <summary>
            /// Constructor for newing vector
            /// </summary>
            /// <param name="x">init x-axis</param>
            /// <param name="y">init y-axis</param>
            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
            }
            #endregion

            /// <summary>
            /// Normalize current vector
            /// </summary>
            public void Normalize() //歸一化 返回向量1,若小於1則返回0
            {
                // v_normalized = v / ||v||,||v||是向量長度[平方根]的符號  公式是sqrt(v1^2 + v2^2)

                float leng = magnitude;
                if (leng >= kEpsilon)
                {
                    x /= leng;
                    y /= leng;
                }
                else
                {
                    x = 0;
                    y = 0;
                }
            }

            /// <summary>
            /// Calculate current length of vector
            /// </summary>
            /// <returns>length of vector</returns>
            public float Magnitude() //返回向量长度为 (x*x+y*y) 的平方根
            {
                return (float)Math.Sqrt(x * x + y * y);
            }

            /// <summary>
            /// Revert current vector
            /// </summary>
            public void Negative() //正值->負值[正負得負],負值->正值[負負得正]
            {
                x *= -1;
                y *= -1;
            }

            /// <summary>
            /// Add other vector
            /// </summary>
            public void Add(Vector2 v)
            {
                x += v.x;
                y += v.y;
            }

            /// <summary>
            /// Subtract other vector
            /// </summary>
            public void Subtract(Vector2 v)
            {
                x -= v.x;
                y -= v.y;
            }

            #region -- Static Methods --
            /// <summary>
            /// Normalize specific vector
            /// </summary>
            /// <param name="v">the specific vector to normalize</param>
            /// <returns>Normalized vector</returns>
            public static Vector2 Normalize(Vector2 v)
            {                
                v.Normalize();

                return v;
            }

            /// <summary>
            /// Calculate distence between vectors
            /// </summary>
            /// <param name="from">the start vector</param>
            /// <param name="to">the end vector</param>
            /// <returns>Distance between from and to vectors</returns>
            public static float Distance(Vector2 from, Vector2 to)//公式distance = sqrt((a.x - b.x)^2 + (a.y - b.y)^2)
            {
                float xDiff = to.x - from.x;
                float yDiff = to.y - from.y;

                return (float)Math.Sqrt((xDiff * xDiff) + (yDiff * yDiff));
            }
            #endregion
        }
    }

課程/作業心得

Normalize有看到kEpsilon但Unity API沒有特別提就去爬一下，原來是用浮點數定義的距離
補交作業

[jack81722]

太讚了，你有去查！
簡單來說，浮點數有誤差問題，所以為了避免這個誤差會給他一個epsilon或稱作tolerance（容許值）
這個值其實可以根據你的需求來定義，所以不一定是要1E-05f，只是unity提供的就是這個數字

[angus945]

答案

public float magnitude { get => Magnitude(); }

            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
            }

            public void Normalize()
            {
                this = Vector2.Normalize(this);
            }
            public float Magnitude()
            {
                return Mathf.Sqrt(x * x + y * y);
            }
            public void Negative()
            {
                x = -x;
                y = -y;
            }

public void Add(Vector2 v)
{
    x += v.x;
    y += v.y;
}
public void Subtract(Vector2 v)
{
    x -= v.x;
    y -= v.y;
}

public static Vector2 Normalize(Vector2 v)
{
    float length = v.Magnitude();

    if (length > kEpsilon)
    {
        v.x = v.x / length;
        v.y = v.y / length;
    }
    else
    {
        v.x = 0;
        v.y = 0;
    }
    return v;
}
public static float Distance(Vector2 from, Vector2 to)
{
    to.Subtract(from);
    return to.magnitude;
}

[jane901201]

Tina( Unity程式 | 佛系劇本 )

我的答案

using System;

namespace PG0003.Questions
{
    public class Question1
    {
        public struct Vector2
        {
            /// <summary>
            /// The tolerance of the float value
            /// </summary>
            private const float kEpsilon = 1E-05f;

            #region -- Constant Vectors --
            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);
            #endregion

            /// <summary>
            /// x-axis
            /// </summary>
            public float x;

            /// <summary>
            /// y-axis
            /// </summary>
            public float y;

            /// <summary>
            /// Length of vector
            /// </summary>
            public float magnitude 
            {
                get
                {
                    return (float) Math.Sqrt(x * x + y * y);
                } 
            }

            #region -- Constructor --
            /// <summary>
            /// Constructor for newing vector
            /// </summary>
            /// <param name="x">init x-axis</param>
            /// <param name="y">init y-axis</param>
            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
            }
            #endregion

            /// <summary>
            /// Normalize current vector
            /// </summary>
            public void Normalize()
            {
                float len = (float)Math.Sqrt(x * x + y * y);
                if (len > kEpsilon)
                {
                    x /= len;
                    y /= len;
                }
                else
                {
                    x = 0;
                    y = 0;
                }
            }

            /// <summary>
            /// Calculate current length of vector
            /// </summary>
            /// <returns>length of vector</returns>
            public float Magnitude()
            {
                return (float) Math.Sqrt(x * x + y * y);
            }

            /// <summary>
            /// Revert current vector
            /// </summary>
            public void Negative()
            {
                x = -x;
                y = -y;
            }

            /// <summary>
            /// Add other vector
            /// </summary>
            public void Add(Vector2 v)
            {
                x += v.x;
                y += v.y;
            }

            /// <summary>
            /// Subtract other vector
            /// </summary>
            public void Subtract(Vector2 v)
            {
                x -= v.x;
                y -= v.y;
            }

            #region -- Static Methods --
            /// <summary>
            /// Normalize specific vector
            /// </summary>
            /// <param name="v">the specific vector to normalize</param>
            /// <returns>Normalized vector</returns>
            public static Vector2 Normalize(Vector2 v)
            {
                v.Normalize();
                return v;
            }

            /// <summary>
            /// Calculate distence between vectors
            /// </summary>
            /// <param name="from">the start vector</param>
            /// <param name="to">the end vector</param>
            /// <returns>Distance between from and to vectors</returns>
            public static float Distance(Vector2 from, Vector2 to)
            {
                float xDis = from.x - to.x;
                float yDis = from.y - to.y;
                return (float) Math.Sqrt(xDis * xDis + yDis * yDis);
            }
            #endregion
        }
    }
}

微積分補考完後就全部都還給老師了哈哈
不過最近在思考程式發展的精進方向時，不管是物理還是機器學習的 AI ，都還是需要數學，應該要花時間把之前的知識補回來了
不然只會寫工具的程式架構，但寫不出裡面的邏輯是件挺尷尬的事情…

[jack81722]

會不會寫架構、底層這件事情很微妙
現在越來越多框架、結構設計的套件可以用了
加上開發節奏越來越快，也不見得有時間把所有東西都看一遍
通常這類底層不要太誇張都不致於造成效能瓶頸
不過理解工具這件事情還是很值得去做
對於技術選型、提升技術能力都有不少幫助

[dun047]

歐雷(程式)

答案

   public class Question1
    {
        public struct Vector2
        {
            /// <summary>
            /// The tolerance of the float value
            /// </summary>
            private const float kEpsilon = 1E-05f;

            #region -- Constant Vectors --
            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);
            #endregion

            /// <summary>
            /// x-axis
            /// </summary>
            public float x;

            /// <summary>
            /// y-axis
            /// </summary>
            public float y;

            /// <summary>
            /// Length of vector
            /// </summary>
            public float magnitude 
            { get
                {
                    return (float)Math.Sqrt(x * x + y * y);
                }        
            }

            #region -- Constructor --
            /// <summary>
            /// Constructor for newing vector
            /// </summary>
            /// <param name="x">init x-axis</param>
            /// <param name="y">init y-axis</param>
            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
            }
            #endregion

            /// <summary>
            /// Normalize current vector
            /// </summary>
            public void Normalize()
            {
                float len = magnitude;
                if (len > kEpsilon)
                { x /= len; y /= len; }
                else
                { x = 0; y = 0; }
            }

            /// <summary>
            /// Calculate current length of vector
            /// </summary>
            /// <returns>length of vector</returns>
            public float Magnitude()
            {
                return (float)Math.Sqrt(x * x + y * y);
            }

            /// <summary>
            /// Revert current vector
            /// </summary>
            public void Negative()
            {
               x = -x;
               y = -y;
            }

            /// <summary>
            /// Add other vector
            /// </summary>
            public void Add(Vector2 v)
            {
                x += v.x;
                y += v.y;
            }

            /// <summary>
            /// Subtract other vector
            /// </summary>
            public void Subtract(Vector2 v)
            {
                x -= v.x;
                y -= v.y;
            }

            #region -- Static Methods --
            /// <summary>
            /// Normalize specific vector
            /// </summary>
            /// <param name="v">the specific vector to normalize</param>
            /// <returns>Normalized vector</returns>
            public static Vector2 Normalize(Vector2 v)
            {
                v.Normalize();
                return v;
            }

            /// <summary>
            /// Calculate distence between vectors
            /// </summary>
            /// <param name="from">the start vector</param>
            /// <param name="to">the end vector</param>
            /// <returns>Distance between from and to vectors</returns>
            public static float Distance(Vector2 from, Vector2 to)
            {
                float _x = from.x - to.x;
                float _y = from.y - to.y;
                return (float)Math.Sqrt(_x * _x + _y * _y);
            }
            #endregion
        }
    }

[MurasakiAurora]

極光（程式）

我的答案

public struct Vector2
        {
            /// <summary>
            /// The tolerance of the float value
            /// </summary>
            private const float kEpsilon = 1E-05f;

            #region -- Constant Vectors --
            public static readonly Vector2 Zero = new Vector2(0, 0);
            public static readonly Vector2 One = new Vector2(1, 1);
            public static readonly Vector2 Left = new Vector2(-1, 0);
            public static readonly Vector2 Right = new Vector2(1, 0);
            public static readonly Vector2 Up = new Vector2(0, 1);
            public static readonly Vector2 Down = new Vector2(0, -1);
            #endregion

            /// <summary>
            /// x-axis
            /// </summary>
            public float x;

            /// <summary>
            /// y-axis
            /// </summary>
            public float y;

            /// <summary>
            /// Length of vector
            /// </summary>
            public float magnitude
            {
                get
                {
                    return (float)Math.Sqrt(x * x + y * y);
                }
            }


            #region -- Constructor --
            /// <summary>
            /// Constructor for newing vector
            /// </summary>
            /// <param name="x">init x-axis</param>
            /// <param name="y">init y-axis</param>
            public Vector2(float x, float y)
            {
                this.x = x;
                this.y = y;
            }
            #endregion

            /// <summary>
            /// Normalize current vector
            /// </summary>
            public void Normalize()
            {
                float len = (float)Math.Sqrt(x * x + y * y);
                if (len > kEpsilon)
                {
                    x /= len; y /= len;
                }
                else
                {
                    x = 0; y = 0;
                }
            }

            /// <summary>
            /// Calculate current length of vector
            /// </summary>
            /// <returns>length of vector</returns>
            public float Magnitude()
            {
                return (float)Math.Sqrt(x * x + y * y);
            }

            /// <summary>
            /// Revert current vector
            /// </summary>
            public void Negative()
            {
                x = -x;
                y = -y;
            }

            /// <summary>
            /// Add other vector
            /// </summary>
            public void Add(Vector2 v)
            {
                x += v.x;
                y += v.y;
            }

            /// <summary>
            /// Subtract other vector
            /// </summary>
            public void Subtract(Vector2 v)
            {
                x -= v.x;
                y -= v.y;
            }

            #region -- Static Methods --
            /// <summary>
            /// Normalize specific vector
            /// </summary>
            /// <param name="v">the specific vector to normalize</param>
            /// <returns>Normalized vector</returns>
            public static Vector2 Normalize(Vector2 v)
            {
                v.Normalize();
                return v;
            }

            /// <summary>
            /// Calculate distence between vectors
            /// </summary>
            /// <param name="from">the start vector</param>
            /// <param name="to">the end vector</param>
            /// <returns>Distance between from and to vectors</returns>
            public static float Distance(Vector2 from, Vector2 to)
            {
                return new Vector2(to.x - from.x, to.y - from.y).magnitude;
            }
            #endregion

        }

這次的題目花了比較久的時間去寫，上完課程之後邊做邊翻影片才做出來的。