added robitcs project

Author: softwarepronto

RoboticsMaster/Robotics/Chips/Chip.cs

@@ -0,0 +1,49 @@
+using System;
+
+using Robotics.Extensions;
+
+namespace Robotics.Chips
+{
+    /// <summary>
+    /// Base class for chips used by Robot. An abstract base class was chosen
+    /// over an interface because there are certain utility methods that can be shared
+    /// such as TestIfTypesAreTheSame which insures operations are performed on arrays 
+    /// containing only the same type.
+    /// </summary>
+    public abstract class Chip
+    {
+        /// <summary>
+        /// Operation performed by chip. Operations are performed on numeric values. As
+        /// the only way to determine numeric values is via code (such as a switch statement)
+        /// a generic is permitted but the data will be validate as numeric (byte, int, double,
+        /// decimal, etc.).
+        /// </summary>
+        /// <param name="data">array of values to be processed</param>
+        /// <returns>result of processing. For scalar results an array of length 1 is returned 
+        /// with the 0th element set to the scalar value</returns>
+        public abstract T[] Operation<T>(T[] data);
+
+        /// <summary>
+        /// Tests is data contains numerica data (byte, int, double, etc.)
+        /// and throws an exception ArgumentException is thrown if type is 
+        /// not numeric 
+        /// </summary>
+        /// <typeparam name="T">Data type of array (must be numeric)</typeparam>
+        /// <param name="data">A null or a zero length array is illegal.
+        /// All types in array are checked if the values are numeric and identical</param>
+        protected static void TestIfTypesAllTheSameNumeric<T>(T[] data)
+        {
+            // The data.IsHomogeneous is to make sure that T is IComparable
+            // and data[0] is a byte (a legal numeric) but the next value
+            // could be a string. T.IsNumericType is not legal for the compiler.
+            if ((data == null) || 
+                (data.Length == 0) || 
+                (!data[0].IsNumericType()) ||
+                (!data.IsHomogeneous()))
+            {
+                throw new ArgumentException(
+                    $"{nameof(Operation)} requires data types to be numeric.");
+            }
+        }
+    }
+}

RoboticsMaster/Robotics/Chips/ChipOfSorts.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections;
+
+using Robotics.Extensions;
+
+namespace Robotics.Chips
+{
+    /// <summary>
+    /// Chip for Robot that allows a Robot to sort data.
+    /// </summary>
+    public class ChipOfSorts : Chip
+    {
+        public enum SortDirection
+        {
+            Ascending,
+            Descending
+        }
+
+        private SortDirection _sortDirection;
+
+        public SortDirection Direction => _sortDirection;
+
+        private class SortDescending : IComparer
+        {
+            public int Compare(object x, object y)
+            {
+                return -1 * ((IComparable)x).CompareTo(y);
+            }
+        }
+
+        /// <summary>
+        /// Chip allows robot to sort data in ascending or descending order
+        /// </summary>
+        /// <param name="sortDirection">Specifies sort direction ascent or descending</param>
+        public ChipOfSorts(SortDirection sortDirection)
+        {
+            _sortDirection = sortDirection;
+        }
+
+        /// <summary>
+        /// Returns new array with data in sorted order.
+        /// </summary>
+        /// <param name="data">data to be sorted. If values is null then return value is null.
+        /// All values in the data array must be of the same type or and ArgumentException 
+        /// is thrown </param>
+        /// <returns>data sorted based off SortDirection specified in the class constructor</returns>
+        public override T[] Operation<T>(T[] data)
+        {
+            if (data == null)
+            {
+                return data;
+            }
+
+            TestIfTypesAllTheSameNumeric(data);
+            // Array.Sort is destructive so clone array first
+            T[] result = (T[])data.Clone();
+
+            // Note from specification:
+            // Sorting algorythm is not important, use standard one 
+            // from any library you want.
+            if (_sortDirection == SortDirection.Ascending)
+            {
+                Array.Sort(result);
+            }
+
+            else
+            {
+                Array.Sort(result, new SortDescending());
+            }
+
+            return result;
+        }
+    }
+}

RoboticsMaster/Robotics/Chips/TotalChip.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Reflection;
+
+using Robotics.Extensions;
+
+namespace Robotics.Chips
+{
+    /// <summary>
+    /// Chip for Robot that allows Robot to sum data
+    /// </summary>
+    public class TotalChip : Chip
+    {
+        private static T Add<T>(object x, object y)
+        {
+            return (T)Convert.ChangeType((dynamic)x + (dynamic)y, typeof(T));
+        }
+        /// <summary>
+        /// Returns the sum (opeator+) of all values in data array via the zeroth element 
+        /// of the returned array. The reason a scaler is not returned is due to a inconsistency
+        /// in the design requriments namely that chips can return arrays or scalars so the
+        /// 0th element is used to return the 
+        /// FYI: name does not match other chips naming pattern (name specified by PM)
+        /// </summary>
+        /// <param name="data">An array of values of the same Type where said type must contain operator+</param>
+        /// <returns>if data is null, value returned in null otherwise returns sum of all elements in data.
+        /// all values in data array</returns>
+        public override T[] Operation<T>(T[] data)
+        {
+            if (data == null)
+            {
+                return data;
+            }
+
+            TestIfTypesAllTheSameNumeric(data);
+
+            T[] result = { default(T) };
+
+            foreach (T datum in data)
+            {
+                result[0] += (dynamic)datum;
+            }
+
+            return result;
+        }
+    }
+}

RoboticsMaster/Robotics/Extensions/ArrayExtensions.cs

@@ -0,0 +1,62 @@
+using System;
+
+namespace Robotics.Extensions
+{
+    /// <summary>
+    /// Extensions to the Array class.
+    /// </summary>
+    public static class ArrayExtensions
+    {
+        /// <summary>
+        /// Returns true if every value in an array is of the same type.
+        /// </summary>
+        /// <param name="array">Array for which homogeneity is determined. 
+        /// This value can be null.</param>
+        /// <returns>return true if array is null or array has a Length of 1 (since is a homogeneous case).
+        /// Returns true if all values in array have the same Type (via GetType()) and
+        /// false otherwise</returns>
+        public static bool IsHomogeneous(this Array array)
+        {
+            // when called as an extenion method this cannot be null but if this
+            // is called as a method it can be null so it can be checked.
+            if ((array == null) || (array.Length == 0))
+            {
+                return true;
+            }
+
+            
+            Type masterType = array.GetValue(0).GetType();
+
+            for (int i = 1; i < array.Length; i++)
+            {
+                if (!array.GetValue(i).GetType().Equals(masterType))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns true if every value in an array is of the same numeric type.
+        /// </summary>
+        /// <param name="array">Array for which homogeneity is determined being all of a single 
+        /// numberic type. If null or zero lenth then the type cannot be numeric so return 
+        /// value is false</param>
+        /// <returns>return false if array is null or array has a Length of 0 since no numeric type
+        /// can be detected. Returns true if all values in array have the same Type (via GetType()) 
+        /// and if this type is a C#/CLI numeric. Returns false otherwise</returns>
+        public static bool IsHomogeneousNumericType(this Array array)
+        {
+            // when called as an extenion method this cannot be null but if this
+            // is called as a method it can be null so it can be checked.
+            if ((array == null) || (array.Length == 0) || (!array.GetValue(0).IsNumericType()))
+            {
+                return false;
+            }
+
+            return IsHomogeneous(array);
+        }
+    }
+}

RoboticsMaster/Robotics/Extensions/ObjectExtensions.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace Robotics.Extensions
+{
+    public static class ObjectExtensions
+    {
+        public static bool IsNumericType(this object o)
+        {
+            switch (Type.GetTypeCode(o.GetType()))
+            {
+                case TypeCode.Byte:
+                case TypeCode.SByte:
+                case TypeCode.UInt16:
+                case TypeCode.UInt32:
+                case TypeCode.UInt64:
+                case TypeCode.Int16:
+                case TypeCode.Int32:
+                case TypeCode.Int64:
+                case TypeCode.Decimal:
+                case TypeCode.Double:
+                case TypeCode.Single:
+                    return true;
+            }
+
+            return false;
+        }
+    }
+}

RoboticsMaster/Robotics/Extensions/TypeExtensions.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Reflection;
+
+namespace Robotics.Extensions
+{
+    /// <summary>
+    /// Extensions to the Type class which includes getting operator+ for a Type.
+    /// In a production environment this could be extended to get all operator types
+    /// (-, less than, greater than, etc.) based off the standard names given these
+    /// overloads by the compiler (op_Inequality, op_GreaterThan, op_Subtraction, etc.)
+    /// </summary>
+    public static class TypeExtensions
+    {
+        private const string OperatorPlustMethodName = "op_Addition";
+
+        /// <summary>
+        /// Returns the method associated with operator+ for a given type
+        /// There is no value returned for numeric types (int32, 
+        /// int64, double, float, etc.) and there is no value returned for string
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns>Returns operator method for specified type or null of 
+        /// operator+ is not associated with the give type.</returns>
+        public static MethodInfo GetOperatorAddition(this Type type)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException(
+                    $"{nameof(TypeExtensions)}.{nameof(GetOperatorAddition)} value of " + 
+                    $"{nameof(type)} cannot be null,");
+            }
+
+            return type.GetMethod(
+                OperatorPlustMethodName,
+                BindingFlags.Static | BindingFlags.Public);
+        }
+    }
+}

RoboticsMaster/Robotics/MainFile.cs

@@ -0,0 +1,39 @@
+/*
+ * The instruction specified:
+ *   There is no right or wrong solution as long as code works, but we give bonus points 
+ *   for a plain-text explanation on why particular design decisions were made and what 
+ *   are the tradeoffs. Put it right into the code in a form of a comment at the 
+ *   beginning of the main file. 
+ *   
+ *   Design Decision 1: there is no need for a main file. This file, mainfile, 
+ *   was include per-instructions above out of respect for the product manager.
+ *   
+ *   Design Decision 2: Units tests were used as "a console application with a test 
+ *   method or two" is not the way projects are tested. This is 2000 era development so 
+ *   Unit Test are simply more natural. 
+ *   
+ *   Design Decision 3: I do not write software as a single file. Applications regardless
+ *   of size are developed using solutions/projets/assemblies and unit tests. I will
+ *   provided both a single file and a full implementation that can be gloned via 
+ *   GitHub.com
+ *   
+ *   Design Decision 4: all design decisions are discussed in the context of where
+ *   apply directly since there is no true MainFile. Since this is a bonus question 
+ *   explanations will be repeated:
+ *   1) Chip is the abstract base class of call chips and Operation method is used
+ *      by a Robot to invoke a chip's action
+ *       public abstract T[] Operation<T>(T[] data);
+ *   2) There is no way to make a generic type T numeric. An Extension method
+ *      was created for the object type ObjectExtensions.IsNumericType which
+ *      determines if a give type in an array of data is numeric (aka is value one
+ *      of byte, int, double, decimal, etc.)
+ *   3) With generics we could have a case when an array is say IComparable and contains
+ *      mixed numeric types. This cannot be supported easily so it is q requirement that
+ *      all data in array is composted of the same numeric type (see extension method
+ *      ArrayExtensions.IsHomogeneousNumericType).
+ *   4) There is an inconsistency in the designing. ChipOfSorts returns an array and
+ *      TotalChip returns scalar. To simplify this the scalar, return an array of length
+ *      1 with the 0th value element set to the scalar result.
+ *   5) The names provided are not consistent: TotalChip and ChipOfSorts so we put our 
+ *      faith in the PM and left the names the same.
+ */

RoboticsMaster/Robotics/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Robotics")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Robotics")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("7451dee6-a65e-4f81-a64d-b6b4f414ed4b")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]