Example #1
0
        void AssertEquals(IList<IList<int>> firstList, IList<IList<int>> secondList)
        {
            Assert.AreEqual(firstList.Count(), secondList.Count());

            firstList = firstList
                .OrderBy(list => list[0])
                .ThenBy(list => list[1])
                .ThenBy(list => list[2])
                .ToList();

            secondList = secondList
                .OrderBy(list => list[0])
                .ThenBy(list => list[1])
                .ThenBy(list => list[2])
                .ToList();

            Assert.IsTrue(firstList
                .Zip(secondList
                    , (firstSubList, secondeSubList) =>
                        firstSubList
                            .Zip(secondeSubList
                                , (first, second) =>
                                    first == second)
                            .All(item => item))
                .All(item => item)); ;
        }
Example #2
0
 private static void CompareEvents(IList<Events.Base> events1, IList<Events.Base> events2)
 {
     Assert.That(events1.Count, Is.EqualTo(events2.Count));
     foreach (var pair in events1.Zip(events2, Tuple.Create))
     {
         Assert.That(pair.Item1, Is.TypeOf(pair.Item2.GetType()));
         var nodeEvent1 = pair.Item1 as Events.Node;
         if (nodeEvent1 == null)
             continue;
         var nodeEvent2 = (Events.Node) pair.Item2;
         Assert.That(nodeEvent1.Anchor, Is.EqualTo(nodeEvent2.Anchor));
         var cstart1 = nodeEvent1 as Events.CollectionStart;
         if (cstart1 != null)
         {
             Assert.That(cstart1.Tag, Is.EqualTo(((Events.CollectionStart)nodeEvent2).Tag));
             continue;
         }
         var scalar1 = nodeEvent1 as Events.Scalar;
         if (scalar1 == null)
             continue;
         var scalar2 = (Events.Scalar) nodeEvent2;
         if (scalar1.ImplicitLevel != ScalarImplicitLevel.Plain &&
             scalar2.ImplicitLevel != ScalarImplicitLevel.Plain)
             Assert.That(scalar1.Tag, Is.EqualTo(scalar2.Tag));
         Assert.That(scalar1.Value, Is.EqualTo(scalar2.Value));
     }
 }
        void AssertEquals(IList<int> subject, IList<int> @object)
        {
            Assert.AreEqual(subject.Count, @object.Count);

            Assert.IsTrue(subject
                .Zip(@object
                    , (first, second) => first == second)
                .All(item => item));
        }
        private static double Distance(IList<int> aChromosone, IEnumerable<int> anotherChromosone)
        {
            var numberOfIdenticalBits =
                aChromosone
                    .Zip(anotherChromosone,
                        (x, y) => new { first = x, second = y })
                    .Count(tuple => tuple.first == tuple.second);

            return numberOfIdenticalBits / (double)aChromosone.Count();
        }
Example #5
0
        private void AssertRecordsAreEqual(IList<Record> actualRecords, params string[] expectedRecords)
        {
            Assert.That(actualRecords, Is.Not.Null, "actualRecords");
            Assert.That(actualRecords.Count, Is.EqualTo(expectedRecords.Length));

            IEnumerable<object> expectedRecordsAsRecords = expectedRecords.Select(ParseRecord);

            var pairs = actualRecords.Zip(expectedRecordsAsRecords, (actual, expected) => new {Actual = actual, Expected = expected});
            foreach (var pair in pairs) {
                Assert.That(pair.Actual, Is.EqualTo(pair.Expected));
            }
        }
 public static ModelShip FromCsvRecord(IList<string> header, IList<string> row)
 {
     var keyedRow = header.Zip(row, (h, r) => new { h, r }).ToDictionary(a => a.h, a => a.r);
     return new ModelShip()
     {
         No = keyedRow["No"].ToInt32(),
         ClassOfShip = keyedRow["ClassOfShip"],
         Name = keyedRow["Name"],
         TaxIncludedPrice = keyedRow["TaxIncludedPrice"].ToInt32OrDefault(System.Globalization.NumberStyles.Currency, -1),
         Price = keyedRow["Price"].ToInt32OrDefault(System.Globalization.NumberStyles.Currency, -1),
         Maker = keyedRow["Maker"]
     };
 }
        void AssertEquers(IList<string> firstList, IList<string> secondList)
        {
            Assert.AreEqual(firstList.Count(), secondList.Count());

            firstList = firstList.OrderBy(item => item).ToList();
            secondList = secondList.OrderBy(item => item).ToList();

            Assert
                .IsTrue(firstList
                    .Zip(secondList
                        , (first, second) =>
                            first == second)
                    .All(item => item));
        }
    public IList<Task<IObjectState>> SaveAllAsync(IList<IObjectState> states,
        IList<IDictionary<string, IParseFieldOperation>> operationsList,
        string sessionToken,
        CancellationToken cancellationToken) {
      var requests = states.Zip(operationsList, (item, ops) => new Dictionary<string, object> {
        { "method", (item.ObjectId == null ? "POST" : "PUT") },
        { "path",  (item.ObjectId == null ?
            string.Format("/1/classes/{0}", Uri.EscapeDataString(item.ClassName)) :
            string.Format("/1/classes/{0}/{1}", Uri.EscapeDataString(item.ClassName),
                Uri.EscapeDataString(item.ObjectId))) },
        { "body", ParseObject.ToJSONObjectForSaving(ops) }
      }).Cast<object>().ToList();

      var batchTasks = ExecuteBatchRequests(requests, sessionToken, cancellationToken);
      var stateTasks = new List<Task<IObjectState>>();
      foreach (var task in batchTasks) {
        stateTasks.Add(task.OnSuccess(t => {
          return ParseObjectCoder.Instance.Decode(t.Result, ParseDecoder.Instance);
        }));
      }

      return stateTasks;
    }
Example #9
0
 private void AssertTokenStreamEquals(IList<Token> eTokens, IList<Token> tokens)
 {
     Assert.AreEqual(eTokens.Count, tokens.Count);
     foreach (var tokenPair in eTokens.Zip(tokens, (token, token1) => new {expected = token, actual = token1}))
     {
         Assert.AreEqual(tokenPair.expected.Kind, tokenPair.actual.Kind);
         Assert.AreEqual(tokenPair.expected.Value, tokenPair.actual.Value);
     }
 }
        /// <summary>
        /// Computes the distance between two points in the sample space
        /// </summary>
        private double distance(IList<double> sample1, IList<double> sample2)
        {
            // Euclidian distance
            return Math.Sqrt(sample1.Zip(sample2, (s1, s2) => Math.Pow(s1 - s2, 2.0)).Sum());

            // Manhattan distance
            //return sample1.Zip(sample2, (s1, s2) => Math.Abs(s1 - s2)).Sum();
        }
 private void AssertKeyCollectionsEquality(IList<Key> expected, IList<Key> actual)
 {
     Assert.NotNull(actual);
     Assert.Equal(expected.Count, actual.Count);
     Assert.True(expected.Zip(actual, (k1, k2) => k1.Equals(k2)).All(r => r));
 }
 private double distance(IList<double> sample1, IList<double> sample2)
 {
     // Simple euclidian distance
     return Math.Sqrt(sample1.Zip(sample2, (s1, s2) => Math.Pow(s1 - s2, 2.0)).Sum());
 }
Example #13
0
        private static void PitchShift2(float pitchShift, int numSampsToProcess, int sampleOverlap, int sampleRate, IList<float> data)
        {
            var fftBuffer = data.Zip(
                Enumerable.Repeat(0f, data.Count),
                (real, imaginary) => new Complex(real, imaginary)).ToArray();

            ShortTimeFourierTransform(fftBuffer, FftDirection.Forward);

            var bins = CalculateBins(SampleRate, fftBuffer);

            var dcOffset = bins[0].Magnitude / fftBuffer.Length;

            var shiftedBins = PitchShiftBins(pitchShift, bins);

            var newBuffer = SynthesizeFft(SampleRate, shiftedBins);

            ShortTimeFourierTransform(newBuffer, FftDirection.Inverse);

            var factor = (newBuffer.Length / 2f);

            for (var i = 0; i < fftBuffer.Length; i++)
            {
                data[i] = newBuffer[i].Real / factor - dcOffset;
            }
        }
Example #14
0
        public Tuple<double, double> DoDeltaCalibration(int numFactors, IList<PointError> zBedProbePoints, bool normalise)
        {
            if (numFactors != 3 && numFactors != 4 && numFactors != 6 && numFactors != 7)
            {
                throw new Exception("Error: " + numFactors + " factors requested but only 3, 4, 6 and 7 supported");
            }
            if (numFactors > zBedProbePoints.Count)
            {
                throw new Exception("Error: need at least as many points as factors you want to calibrate");
            }

            // Transform the probing points to motor endpoints and store them in a matrix, so that we can do multiple iterations using the same data
            var probeMotorPositions = new PointError[zBedProbePoints.Count];
            var corrections = new double[zBedProbePoints.Count];
            var initialSumOfSquares = 0.0;
            for (var i = 0; i < zBedProbePoints.Count; ++i)
            {
                corrections[i] = 0.0;
                var machinePos = new double[3]
                {
                    zBedProbePoints[i].X,
                    zBedProbePoints[i].Y,
                    0
                };

                probeMotorPositions[i] = new PointError(Transform(machinePos, 0), Transform(machinePos, 1), Transform(machinePos, 2));

                initialSumOfSquares += FSquare(zBedProbePoints[i].X) + FSquare(zBedProbePoints[i].Y) + FSquare(zBedProbePoints[i].ZError);
            }

            // remove any erroneous data points..  maybe not the best idea??
            var zip = zBedProbePoints
                .Zip(probeMotorPositions, (point, pos) => new { point, pos })
                .Where(_ => !_.pos.X.Equals(double.NaN) && !_.pos.Y.Equals(double.NaN) && !_.pos.ZError.Equals(double.NaN))
                .ToList();
            zBedProbePoints = (from z in zip select z.point).ToList();
            probeMotorPositions = (from z in zip select z.pos).ToArray();

            // Do 1 or more Newton-Raphson iterations
            var iteration = 0;
            double expectedRmsError;
            for (;;)
            {
                // Build a Nx7 matrix of derivatives with respect to xa, xb, yc, za, zb, zc, diagonal.
                var derivativeMatrix = new double[zBedProbePoints.Count, numFactors];
                for (var i = 0; i < zBedProbePoints.Count; ++i)
                {
                    for (var j = 0; j < numFactors; ++j)
                    {
                        derivativeMatrix[i, j] =
                            ComputeDerivative(j, probeMotorPositions[i].X, probeMotorPositions[i].Y, probeMotorPositions[i].ZError);
                    }
                }

                // Now build the normal equations for least squares fitting
                var normalMatrix = new double[numFactors, numFactors + 1];
                double temp;
                for (var i = 0; i < numFactors; ++i)
                {
                    for (var j = 0; j < numFactors; ++j)
                    {
                        temp = derivativeMatrix[0,i] * derivativeMatrix[0,j];
                        for (var k = 1; k < zBedProbePoints.Count; ++k)
                        {
                            temp += derivativeMatrix[k,i] * derivativeMatrix[k,j];
                        }
                        normalMatrix[i,j] = temp;
                    }
                    temp = derivativeMatrix[0,i] * -(zBedProbePoints[0].ZError + corrections[0]);
                    for (var k = 1; k < zBedProbePoints.Count; ++k)
                    {
                        temp += derivativeMatrix[k,i] * -(zBedProbePoints[k].ZError + corrections[k]);
                    }
                    normalMatrix[i, numFactors] = temp;
                }

                double[] solution = GaussJordan(ref normalMatrix, numFactors);
                if (solution.Any(_ => _.Equals(double.NaN)))
                    throw new Exception("Unable to calculate corrections. Please make sure the bed probe points are all distinct.");

                //if (debug)
                //{
                //    DebugPrint(PrintVector("Solution", solution));

                //    // Calculate and display the residuals
                //    var residuals = [];
                //    for (var i = 0; i < numPoints; ++i)
                //    {
                //        var r = zBedProbePoints[i];
                //        for (var j = 0; j < numFactors; ++j)
                //        {
                //            r += solution[j] * derivativeMatrix.data[i][j];
                //        }
                //        residuals.push(r);
                //    }
                //    DebugPrint(PrintVector("Residuals", residuals));
                //}

                Adjust(numFactors, solution, normalise);

                // Calculate the expected probe heights using the new parameters
                {
                    var expectedResiduals = new double[zBedProbePoints.Count];
                    var sumOfSquares = 0.0;
                    for (var i = 0; i < zBedProbePoints.Count; ++i)
                    {
                        probeMotorPositions[i] = new PointError(probeMotorPositions[i].X + solution[0], probeMotorPositions[i].Y + solution[1], probeMotorPositions[i].ZError + solution[2]);
                        var newZ = InverseTransform(probeMotorPositions[i].X, probeMotorPositions[i].Y, probeMotorPositions[i].ZError);
                        corrections[i] = newZ;
                        expectedResiduals[i] = zBedProbePoints[i].ZError + newZ;
                        sumOfSquares += FSquare(expectedResiduals[i]);
                    }

                    expectedRmsError = Math.Sqrt(sumOfSquares / zBedProbePoints.Count);
                }

                // Decide whether to do another iteration Two is slightly better than one, but three doesn't improve things.
                // Alternatively, we could stop when the expected RMS error is only slightly worse than the RMS of the residuals.
                ++iteration;
                if (iteration == 2) { break; }
            }

            return Tuple.Create(Math.Sqrt(initialSumOfSquares / zBedProbePoints.Count), expectedRmsError);
        }
 public static bool Checkit(IList<double> first, IList<double> second)
 {
     return (first.Count == second.Count) && !first.Zip(second, (f, s) => (f - s)).Any(d => Math.Abs(d) > 1e-6);
 }
Example #16
0
        private static void WriteIcoToStream(Stream stream, IList<Bitmap> bitmaps)
        {
            if (bitmaps.Any(bmp => bmp.Width> 256 || bmp.Height> 256))
            {
            throw new ArgumentException(
                "ICO files cannot contain images with dimensions greater than 256x256 pixels");
            }
            bitmaps = bitmaps.Where(bmp => bmp.Width> 0 && bmp.Height> 0).ToList();

            if (bitmaps.Count> ushort.MaxValue)
            {
            throw new ArgumentException(
                "ICO files can only contain up to " + short.MaxValue + " images.");
            }

            IList<byte[]> pngImages = new List<byte[]>(bitmaps.Count);
            foreach (var bmp in bitmaps)
            {
            using (var pngStream = new MemoryStream())
            {
                bmp.Save(pngStream, ImageFormat.Png);
                pngImages.Add(pngStream.ToArray());
            }
            }

            var numImages = (ushort) bitmaps.Count;
            WriteIcoMainHeader(stream, numImages);

            uint headerSize = 6;
            uint imageHeaderSize = 16;
            uint offset = headerSize + numImages * imageHeaderSize;
            foreach (var images in bitmaps.Zip(pngImages, Tuple.Create))
            {
            var bmp = images.Item1;
            var png = images.Item2;
            var imageSize = (uint) png.Length;
            // The direct cast to a byte here is safe. We validate the image size above,
            // so all images have a width/height in the range [1, 256]. Casting [1, 255]
            // to a byte returns the same number, and casting 256 returns 0, which represents
            // an image of size 256 bytes in the ICO format.
            WriteIcoImageHeader(stream, (byte) bmp.Width, (byte) bmp.Height, imageSize, offset);
            offset += imageSize;
            }

            foreach (var png in pngImages)
            {
            stream.Write(png, 0, png.Length);
            }
        }