public void CanConvertArrayToSparseVector()
 {
     var array = new[] { new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1) };
     var vector = new SparseVector(array);
     Assert.IsInstanceOf(typeof(SparseVector), vector);
     CollectionAssert.AreEqual(array, array);
 }

        public ExampleSet GetProof(SparseVector x)
        {
            ExampleSet res = new ExampleSet();

            List<ExampleDistancePair> list = new List<ExampleDistancePair>();

            foreach (Example e in m_t_set.Examples)
            {
                list.Add(new ExampleDistancePair(e, SparseVector.Distance(x, e.X)));
            }

            list.Sort();

            int[] votes = new int[m_catnum];
            for (int i = 0; i < votes.Length; i++)
            {
                votes[i] = 0;
            }

            for (int i = 0; i < this.m_k; i++)
            {
                ExampleDistancePair pair = list[i];
                res.AddExample(pair.Example);
            }

            return res;
        }

        public double Compute(SparseVector x, SparseVector z)
        {
            double temp;

            temp = ((SparseVector)(x - z)).Magnitude;
            return Math.Exp(-sigma * (temp * temp));
        }

 public void CanConvertSparseVectorToArray()
 {
     var vector = new SparseVector(Data);
     var array = vector.ToArray();
     Assert.IsInstanceOf(typeof(double[]), array);
     CollectionAssert.AreEqual(vector, array);
 }

        //-- VMP -------------------------------------------------------------------------------------------

		/// <summary>
		/// Evidence message for VMP
		/// </summary>
		/// <param name="sample">Incoming message from 'sample'. Must be a proper distribution.  If any element is uniform, the result will be uniform.</param>
		/// <param name="probsTrue">Incoming message from 'probsTrue'. Must be a proper distribution.  If any element is uniform, the result will be uniform.</param>
		/// <param name="MeanLog">Buffer 'MeanLog'.</param>
		/// <param name="MeanLogOneMinus">Buffer 'MeanLogOneMinus'.</param>
		/// <returns>Average of the factor's log-value across the given argument distributions</returns>
		/// <remarks><para>
		/// The formula for the result is <c>sum_(sample,probsTrue) p(sample,probsTrue) log(factor(sample,probsTrue))</c>.
		/// Adding up these values across all factors and variables gives the log-evidence estimate for VMP.
		/// </para></remarks>
		/// <exception cref="ImproperMessageException"><paramref name="sample"/> is not a proper distribution</exception>
		/// <exception cref="ImproperMessageException"><paramref name="probsTrue"/> is not a proper distribution</exception>
		public static double AverageLogFactor([Proper] SparseBernoulliListBase sample,
			[Proper] SparseBetaList probsTrue, SparseVector MeanLog, SparseVector MeanLogOneMinus)
        {
			//var MeanLogOneMinus = probsTrue.GetMeanLogOneMinus();
            var p = sample.GetProbTrueVector();
			var res = p * MeanLog + (1 - p) * MeanLogOneMinus;
            return res.Sum();
        }

 /// <summary>
 /// Adds each element of vec to corresponding element of addTo vector
 /// addTo vector is being changed in place
 /// </summary>
 public static void AddInPlace(SparseVector<double> addTo, SparseVector<double> vec)
 {
     foreach (var vecIdx in vec.InnerIdx)
     {
         var num = addTo.TryGet(vecIdx, 0.0);
         addTo[vecIdx] = num + vec[vecIdx];
     }
 }

 public static SparseVector<double> Multiply(double scalar, SparseVector<double> vector)
 {
     var newVector = vector.DeepClone();
     for (int i = 0; i < newVector.InnerDat.Count; i++ )
     {
         newVector.SetDirect(i, newVector.InnerDat[i] * scalar);
     }
     return newVector;
 }

 public void CanCallUnaryNegationOperatorOnSparseVector()
 {
     var vector = new SparseVector(_data);
     var other = -vector;
     for (var i = 0; i < _data.Length; i++)
     {
         Assert.AreEqual(-_data[i], other[i]);
     }
 }

        public void AddRowTestAddsRowWithGivenVector()
        {
            SparseVector v = new SparseVector(TestMatrix.Columns);
            v[2] = 5.1f;
            TestMatrix.AddRow(v);

            float expected = 5.1f;

            Assert.AreEqual(expected, TestMatrix[3, 2]);
        }

        /// <summary>
        /// Creates a new instance of the Vector class.
        /// </summary>
        /// <param name="data">The array to create this vector from.</param>
        /// <returns>The new <c>Vector</c>.</returns>
        protected override Vector<double> CreateVector(IList<double> data)
        {
            var vector = new SparseVector(data.Count);
            for (var index = 0; index < data.Count; index++)
            {
                vector[index] = data[index];
            }

            return vector;
        }

        public void ConstructorThrowsArgumentNullExceptionIfNullArgumentPassed()
        {
            // arrange

            // act
            var sv = new SparseVector<double>(null);
            
            // assert
            Assert.Fail("SparseVector ctor must throw ArgumentNullException if null argument passed.");
        }

        /// <summary>
        /// Divides each element of dividee with corresponding element of divisor in place
        /// Dividee is being changed
        /// </summary>
        public static void DivideInPlace(SparseVector<double> dividee, SparseVector<double> divisor)
        {
            foreach (var divIdx in divisor.InnerIdx)
            {
                var num = dividee.TryGet(divIdx, 0.0);
                if (num < Double.Epsilon)
                    continue;

                dividee[divIdx] = num/divisor[divIdx];
            }
        }

        public void CanCreateSparseVectorFromArray()
        {
            var data = new double[Data.Length];
            Array.Copy(Data, data, Data.Length);
            var vector = new SparseVector(data);

            for (var i = 0; i < data.Length; i++)
            {
                Assert.AreEqual(data[i], vector[i]);
            }
        }

        public Binary_SVM_SMO(int n)
        {
            this.m_NonBound = new List<int>();
            this.m_rand = new Random();
            this.m_weight = new SparseVector(n);

            // foamliu, 2008/12/29, default values
            this.m_c = Constants.SVM_C;
            this.m_eta = Constants.SVM_Eta;
            this.m_tolerance = Constants.SVM_Tolerance;
            this.m_epsilon = Constants.SVM_Epsilon;
        }

        public void AddColumnTestAddsColumnWithGivenValue()
        {
            SparseVector expected = new SparseVector(TestMatrix.Rows);
            expected[0] = 5.0f;
            expected[1] = 5.0f;
            expected[2] = 5.0f;

            TestMatrix.AddColumn(5.0f);

            Assert.IsTrue(expected.ApproximatelyEqual(
                TestMatrix.ColumnVector(TestMatrix.Columns - 1)));
        }

        public void CanAddTwoSparseVectorsUsingOperator()
        {
            var vector = new SparseVector(_data);
            var other = new SparseVector(_data);
            var result = vector + other;

            for (var i = 0; i < _data.Length; i++)
            {
                Assert.AreEqual(_data[i], vector[i], "Making sure the original vector wasn't modified.");
                Assert.AreEqual(_data[i], other[i], "Making sure the original vector wasn't modified.");
                Assert.AreEqual(_data[i] * 2.0, result[i]);
            }
        }

        public void CanAddTwoSparseVectorsUsingOperator()
        {
            var vector = new SparseVector(Data);
            var other = new SparseVector(Data);
            var result = vector + other;

            for (var i = 0; i < Data.Length; i++)
            {
                AssertHelpers.AreEqual(Data[i], vector[i]);
                AssertHelpers.AreEqual(Data[i], other[i]);
                AssertHelpers.AreEqual(Data[i] * 2.0f, result[i]);
            }
        }

        public void CanAddTwoSparseVectorsUsingOperator()
        {
            var vector = new SparseVector(Data);
            var other = new SparseVector(Data);
            var result = vector + other;
            CollectionAssert.AreEqual(Data, vector, "Making sure the original vector wasn't modified.");
            CollectionAssert.AreEqual(Data, other, "Making sure the original vector wasn't modified.");

            for (var i = 0; i < Data.Length; i++)
            {
                Assert.AreEqual(Data[i] * 2.0f, result[i]);
            }
        }

        public void IndexedPropertyGetAccessorReturnsWhatWasSavedThroughConstructor()
        {
            // arrange           
            var originalVector = SparseVectorHelper.GenerateRandomVector(1000, 0.7, () => SparseVectorHelper.RandomInInterval(-100, 100, 2));

            // act
            var sv = new SparseVector<double>(originalVector);

            // assert
            foreach (var element in originalVector)
            {
                Assert.AreEqual(element.Value, sv[element.Key]);
            }
        }

        public static SparseVector<double> Add(SparseVector<double> v1, SparseVector<double> v2)
        {
            var newVector = new SparseVector<double>();
            var v1LastI = v1.Count > 0 ? v1.Last.Idx : 0;
            var v2LastI = v2.Count > 0 ? v2.Last.Idx : 0;
            var limit = Math.Max(v1LastI, v2LastI);

            for (int i = 0; i < limit; i++)
            {
                var sum = v1.TryGet(i, 0.0) + v2.TryGet(i, 0.0);
                if (sum > Double.Epsilon)
                    newVector[i] = sum;
            }

            return newVector;
        }