using System;

using System.Collections.Generic;

using System.Text;

public struct Vector<T> {

​

    private T[] Values;

    private int Size;

​

    public Vector(int size) {

        Values = new T[size];

        Size = size;

    }

​

    public T this[int i] {

        get => Values[i];

        set => Values[i] = value;

    }

​

    public T Dot(Vector<T> r) {

        T result = (dynamic) 0;

        for(int i = 0; i < Size; i++) {

            result += (dynamic) Values[i] * r[i];

        }

        return result;

    }

​

    public Vector<T> Min(Vector<T> r) {

        Vector<T> result = new Vector<T>(Size);

        for(int i = 0; i < Size; i++) {

            result[i] = (dynamic) Values[i] < r[i] ? Values[i] : r[i];

        }

        return result;

    }

​

    public T Min() {

        T minValue = Values[0];

        for(int i = 0; i < Size; i++) {

            if((dynamic) Values[i] < minValue) {

                minValue = Values[i];

            }

        }

        return minValue;

    }

​

    public Vector<T> Max(Vector<T> r) {

        Vector<T> result = new Vector<T>(Size);

        for(int i = 0; i < Size; i++) {

            result[i] = (dynamic) Values[i] > r[i] ? Values[i] : r[i];

        }

        return result;

    }

​

    public T Max() {

        T maxValue = Values[0];

        for(int i = 0; i < Size; i++) {

            if((dynamic) Values[i] > maxValue) {

                maxValue = Values[i];

            }

        }

        return maxValue;

    }

​

    public T LengthSquared() {

        return Dot(this);

    }

​

    public T Length() {

        return MathF.Sqrt((dynamic) LengthSquared());

    }

​

    public Vector<T> Normalized() {

        return this / Length();

    }

​

    public Vector<T> Lerp(Vector<T> r, T lerpFactor) {

        return (r - this) * lerpFactor + this;

    }

​

    public static Vector<T> operator +(Vector<T> a, Vector<T> b) {

        Vector<T> result = new Vector<T>(a.Size);

        for(int i = 0; i < a.Size; i++) {

            result[i] = (dynamic) a[i] + b[i];

        }

        return result;

    }

​

    public static Vector<T> operator +(Vector<T> a, T b) {

        Vector<T> result = new Vector<T>(a.Size);

        for(int i = 0; i < a.Size; i++) {

            result[i] = (dynamic) a[i] + b;

        }

        return result;

    }

​

    public static Vector<T> operator -(Vector<T> a, Vector<T> b) {

        Vector<T> result = new Vector<T>(a.Size);

        for(int i = 0; i < a.Size; i++) {

            result[i] = (dynamic) a[i] - b[i];

        }

        return result;

    }

​

    public static Vector<T> operator -(Vector<T> a, T b) {

        Vector<T> result = new Vector<T>(a.Size);

        for(int i = 0; i < a.Size; i++) {

            result[i] = (dynamic) a[i] - b;

        }

        return result;

    }

​

    public static Vector<T> operator *(Vector<T> a, Vector<T> b) {

        Vector<T> result = new Vector<T>(a.Size);

        for(int i = 0; i < a.Size; i++) {

            result[i] = (dynamic) a[i] * b[i];

        }

        return result;

    }

​

    public static Vector<T> operator *(Vector<T> a, T b) {

        Vector<T> result = new Vector<T>(a.Size);

        for(int i = 0; i < a.Size; i++) {

            result[i] = (dynamic) a[i] * b;

        }

        return result;

    }

​

    public static Vector<T> operator /(Vector<T> a, Vector<T> b) {

        Vector<T> result = new Vector<T>(a.Size);

        for(int i = 0; i < a.Size; i++) {

            result[i] = (dynamic) a[i] / b[i];

        }

        return result;

    }

​

    public static Vector<T> operator /(Vector<T> a, T b) {

        Vector<T> result = new Vector<T>(a.Size);

        for(int i = 0; i < a.Size; i++) {

            result[i] = (dynamic) a[i] / b;

        }

        return result;

    }

}