public void Test_1_plus_1_plus_1()
        {
            var res = Arithmetics.Add(true, true, true);

            res.High.Should().BeTrue();
            res.Low.Should().BeTrue();
        }
Example #2
0
        public void TestAgainMethodSum()
        {
            Arithmetics a = new Arithmetics();


            Assert.AreEqual(15, a.Sum(new int[] { 1, 2, 3, 4, 5 }));
        }
Example #3
0
        } // End Property Slope


        // https://stackoverflow.com/questions/17692922/check-is-a-point-x-y-is-between-two-points-drawn-on-a-straight-line
        public bool IsPointOnLine(MyPoint2D <T> p)
        {
            T norm = this.Vector.MagnitudeSquared;
            MyVector2D <T> vec1 = new MyVector2D <T>(this.m_start, p);
            MyVector2D <T> vec2 = new MyVector2D <T>(this.m_end, p);

            T dist = Arithmetics <T> .Add(vec1.MagnitudeSquared, vec2.MagnitudeSquared);

            if (norm.Equals(dist))
            {
                return(true);
            }

            T delta = Arithmetics <T> .Subtract(vec1.MagnitudeSquared, vec2.MagnitudeSquared);

            decimal decDelta = System.Convert.ToDecimal(delta);

            decDelta = System.Math.Abs(decDelta);

            // Greatest possible floating-point difference
            decimal decFloatEpsilon = System.Convert.ToDecimal(float.Epsilon);

            if (decDelta <= decFloatEpsilon)
            {
                return(true);
            }

            return(false);
        } // End Function IsPointOnLine
Example #4
0
        public void Test_1_plus_0()
        {
            var res = Arithmetics.HalfAdder(true, false);

            res.High.Should().BeFalse();
            res.Low.Should().BeTrue();
        }
Example #5
0
        protected float CalculateVelocityManeuver(float aVelocity)
        {
            float velocity = Arithmetics.KeepInRange(aVelocity, Min, Max);
            float diff     = Diff(velocity) / 2;

            return(Arithmetics.KeepInRange(diff * Agression, Input.Limits.Pitch.Min, Input.Limits.Pitch.Max));
        }
        public void Test_0_plus_0_plus_0()
        {
            var res = Arithmetics.Add(false, false, false);

            res.High.Should().BeFalse();
            res.Low.Should().BeFalse();
        }
Example #7
0
        public void Test_0_plus_1()
        {
            var res = Arithmetics.HalfAdder(false, true);

            res.High.Should().BeFalse();
            res.Low.Should().BeTrue();
        }
Example #8
0
        /// <summary>
        /// Resamples data from multiple channels to single one.
        /// </summary>
        /// <param name="audio">audio with</param>
        public static short[] ConvertToMono(IAudioFormat audio)
        {
            if (audio == null)
            {
                throw new ArgumentNullException("Argument 'audio' is null.");
            }
            if (audio.Data == null)
            {
                throw new ArgumentNullException("Argument 'audio.Data' is null");
            }

            switch (audio.Channels)
            {
            case 1:
                return(audio.Data);

            case 2:
                short[] mono = new short[audio.NumOfDataSamples / 2];

                for (int i = 0; i < audio.NumOfDataSamples; i += 2)                         //4 bytes per loop are processed (2 left + 2 right samples)
                {
                    mono[i / 2] = Arithmetics.Average(audio.Data[i], audio.Data[i + 1]);
                }

                return(mono);

            default:
                throw new NotImplementedException($"Convert from {audio.Channels} channels to mono is not supported.");
            }
        }
Example #9
0
        static void Main(string[] args)
        {
            Arithmetics add   = x => x.Select(element => element + 1).ToArray();
            Arithmetics mult  = x => x.Select(element => element * 2).ToArray();
            Arithmetics subtr = x => x.Select(element => element - 1).ToArray();

            int[] inputNums = Console.ReadLine().Split().Select(int.Parse).ToArray();

            string command;

            while ((command = Console.ReadLine()) != "end")
            {
                switch (command)
                {
                case "add":
                    inputNums = add(inputNums);
                    break;

                case "multiply":
                    inputNums = mult(inputNums);
                    break;

                case "subtract":
                    inputNums = subtr(inputNums);
                    break;

                case "print":
                    Console.WriteLine(string.Join(' ', inputNums));
                    break;

                default:
                    throw new ArgumentException("Invalid action!");
                }
            }
        }
        public void Minus_one_is_less_than_zero()
        {
            // Act
            var equalsZero = Arithmetics.IsLessThanZero(new Byte2(-1));

            // Assert
            equalsZero.Should().BeTrue();
        }
Example #11
0
        public MyVector3D(MyPoint3D <T> a, MyPoint3D <T> b)
        {
            this.X = Arithmetics <T> .Subtract(a.X, b.X);

            this.Y = Arithmetics <T> .Subtract(a.Y, b.Y);

            this.Z = Arithmetics <T> .Subtract(a.Z, b.Z);
        } // End Constructor
        public void Test_1_plus_0_plus_1()
        {
            var res = Arithmetics.AddTwoBits(new Bit2(false, true), new Bit2(false, false), true);

            res.High.Low.Should().BeFalse();
            res.Low.High.Should().BeTrue();
            res.Low.Low.Should().BeFalse();
        }
        public void Test_0_plus_0_plus_0()
        {
            var nibble = Arithmetics.AddTwoBits(new Bit2(false, false), new Bit2(false, false), false);

            nibble.High.Low.Should().BeFalse();
            nibble.Low.High.Should().BeFalse();
            nibble.Low.Low.Should().BeFalse();
        }
        public void Minvalue_is_less_than_zero()
        {
            // Act
            var equalsZero = Arithmetics.IsLessThanZero(new Byte2(short.MinValue));

            // Assert
            equalsZero.Should().BeTrue();
        }
        public void Zero_is_not_less_than_zero()
        {
            // Act
            var equalsZero = Arithmetics.IsLessThanZero(new Byte2(0));

            // Assert
            equalsZero.Should().BeFalse();
        }
Example #16
0
        public void Zero_equals_zero()
        {
            // Act
            var equalsZero = Arithmetics.EqualsZero(new Nibble(0));

            // Assert
            equalsZero.Should().BeTrue();
        }
Example #17
0
        } // End Function IsPointOnLine

        public static MyVector2D <T> ToVector(MyPoint2D <T> start, MyPoint2D <T> end)
        {
            T x = Arithmetics <T> .Subtract(end.X, start.X);

            T y = Arithmetics <T> .Subtract(end.Y, start.Y);

            return(new MyVector2D <T>(x, y));
        } // End Function ToVector
Example #18
0
        public void Fifteen_does_not_equal_zero()
        {
            // Act
            var equalsZero = Arithmetics.EqualsZero(new Nibble(15));

            // Assert
            equalsZero.Should().BeFalse();
        }
Example #19
0
        } // End Property Normalized


        // http://mathworld.wolfram.com/NormalVector.html
        // https://stackoverflow.com/questions/1243614/how-do-i-calculate-the-normal-vector-of-a-line-segment
        public static MyVector2D <T> GetNormalVector(MyVector2D <T> vec)
        {
            MyVector2D <T> normal1 = new MyVector2D <T>(Arithmetics <T> .Minus(vec.Y), vec.X);

            // MyVector2D<T> normal2 = new MyVector2D<T>(vec.Y, Arithmetics<T>.Minus(vec.X));

            return(normal1);
        } // End Function GetNormalVector
Example #20
0
        public IActionResult About()
        {
            int value1 = 2;
            int value2 = 2;
            ViewData["Message"] = string.Format("{0} + {1} = {2}", value1, value2,
                Arithmetics.Add(value1, value2));

            return View();
        }
        public void Maxvalue_is_not_less_than_zero()
        {
            // Act
            var byte2      = new Byte2(short.MaxValue);
            var equalsZero = Arithmetics.IsLessThanZero(byte2);

            // Assert
            equalsZero.Should().BeFalse();
        }
Example #22
0
        public void TestMethodSum()
        {
            Arithmetics a = new Arithmetics();

            //a test composed out of two subtests

            Assert.AreEqual(23.5, a.Sum(13.5, 10));

            Assert.AreEqual(23, a.Sum(13, 10));
        }
Example #23
0
        } // End Function Schnittpunktli

        // https://en.wikipedia.org/wiki/Determinant
        // | a  b |
        // | c  d |
        private static T Determinant2d(T a, T b, T c, T d)
        {
            T f1 = Arithmetics <T> .Multiply(a, d);

            T f2 = Arithmetics <T> .Multiply(b, c);

            T result = Arithmetics <T> .Subtract(f1, f2);

            return(result);
        } // End Function Determinant2d
Example #24
0
        } // End Operator *

        public static MyVector2D <T> operator *(MyVector2D <T> a, T b)
        {
            MyVector2D <T> v = a.Clone();

            v.X = Arithmetics <T> .Multiply(v.X, b);

            v.Y = Arithmetics <T> .Multiply(v.Y, b);

            return(v);
        } // End Operator *
Example #25
0
        } // End Operator +

        public static MyVector2D <T> operator -(MyVector2D <T> a, MyVector2D <T> b)
        {
            MyVector2D <T> v = a.Clone();

            v.X = Arithmetics <T> .Subtract(v.X, b.X);

            v.Y = Arithmetics <T> .Subtract(v.Y, b.Y);

            return(v);
        } // End Operator -
Example #26
0
        } // End Operator +

        public static MyPoint2D <T> operator +(MyPoint2D <T> point, MyVector2D <T> a)
        {
            MyPoint2D <T> p = point.Clone();

            p.X = Arithmetics <T> .Add(p.X, a.X);

            p.Y = Arithmetics <T> .Add(p.Y, a.Y);

            return(p);
        } // End Operator +
Example #27
0
        public void Test_MinValue_increment()
        {
            // Arrange
            var a = new Byte2(short.MinValue);

            // Act
            var byteResult = Arithmetics.Increment(a);

            // Assert
            byteResult.ToInt16().Should().Be(short.MinValue + 1);
        }
Example #28
0
        public void Test_0_increment()
        {
            // Arrange
            var a = new Byte2(0);

            // Act
            var byteResult = Arithmetics.Increment(a);

            // Assert
            byteResult.ToInt16().Should().Be(1);
        }
Example #29
0
        } // End function CrossP

        // The dot product (also called the scalar product) is the magnitude of
        // vector b multiplied by the size of the projection of a onto b.
        // The size of the projection is a cosθ (where θ is the angle between the 2 vectors).
        // https://coderwall.com/p/icvt-g/2d-vector-dot-product
        // where theta is the angle between u and v, given by the dot product
        // cos(theta) = u dotp v
        public static T DotP(MyVector2D <T> a, MyVector2D <T> b)
        {
            T s1 = Arithmetics <T> .Multiply(a.X, b.X);

            T s2 = Arithmetics <T> .Multiply(a.Y, b.Y);

            //A * B = ax*bx+ay*by+az*bz
            T retValue = Arithmetics <T> .Add(s1, s2);

            return(retValue);
        } // End function DotP
Example #30
0
        } // End Property NormalVector


        // http://mathworld.wolfram.com/CrossProduct.html
        // the cross product is a vector that is perpendicular to both
        // a and b and thus normal to the plane containing them
        // |u x v| = |u| x |v| * sin(phi)
        public static T CrossP(MyVector2D <T> a, MyVector2D <T> b)
        {
            // crossp = det(a,b) = a.X*b.Y- a.Y*b.X
            T s1 = Arithmetics <T> .Multiply(a.X, b.Y);

            T s2 = Arithmetics <T> .Multiply(a.Y, b.X);

            T retValue = Arithmetics <T> .Subtract(s1, s2);

            return(retValue);
        } // End function CrossP