C# Triplet类代码示例

    public static Triplet HUSLPToLCH(Triplet triple)
    {
        double H = triple.a;
        double S = triple.b;
        double L = triple.c;

        if (L > 99.9999999)
        {
            triple.a = 100;
            triple.b = 0;
            triple.c = H;

            return triple;
        }

        if (L < 0.00000001)
        {
            triple.a = 0;
            triple.b = 0;
            triple.c = H;

            return triple;
        }

        double max = MaxSafeChromaForL(L);
        double C = max / 100 * S;

        triple.a = L;
        triple.b = C;
        triple.c = H;

        return triple;
    }

        public void CanCompareTwoNullableDifferentTypeTriplets()
        {
            var triplet1 = new Triplet<string, int?, Type>("1", 2, typeof(Console));
            var triplet2 = new Triplet<string, int?, Type>("1", 2, typeof(Console));
            var triplet3 = new Triplet<string, int?, Type>("1", null, typeof(Console));

            triplet2.Should().Be(triplet1);
            triplet3.Should().Not.Be(triplet1);
        }

        public void CanCompareTwoNullableTriplets()
        {
            var pair1 = new Triplet<int?>(1, null, 42);
            var pair2 = new Triplet<int?>(1, null, 42);
            var pair3 = new Triplet<int?>(null, 2, null);

            pair2.Should().Be(pair1);
            pair3.Should().Not.Be(pair1);
        }

		public static LNode unroll(LNode var, LNode cases, LNode body, IMessageSink sink)
		{
			if (!cases.Calls(S.Tuple) && !cases.Calls(S.Braces))
				return Reject(sink, cases, "unroll: the right-hand side of 'in' should be a tuple");

			// Maps identifiers => replacements. The integer counts how many times replacement occurred.
			var replacements = InternalList<Triplet<Symbol, LNode, int>>.Empty;
			if (var.IsId && !var.HasPAttrs()) {
				replacements.Add(Pair.Create(var.Name, (LNode)LNode.Missing, 0));
			} else {
				var vars = var.Args;
				if ((var.Calls(S.Tuple) || var.Calls(S.Braces)) && vars.All(a => a.IsId && !a.HasPAttrs())) {
					replacements = new Triplet<Symbol, LNode, int>[vars.Count].AsInternalList();
					for (int i = 0; i < vars.Count; i++) {
						replacements.InternalArray[i].A = vars[i].Name;
						
						// Check for duplicate names
						for (int j = 0; j < i; j++)
							if (replacements[i].A == replacements[j].A && replacements[i].A.Name != "_")
								sink.Write(Severity.Error, vars[i], "unroll: duplicate name in the left-hand tuple"); // non-fatal
					}
				} else
					return Reject(sink, cases, "unroll: the left-hand side of 'in' should be a simple identifier or a tuple of simple identifiers.");
			}

			UnrollCtx ctx = new UnrollCtx { Replacements = replacements };
			WList<LNode> output = new WList<LNode>();
			int iteration = 0;
			foreach (LNode replacement in cases.Args)
			{
				iteration++;
				bool tuple = replacement.Calls(S.Tuple) || replacement.Calls(S.Braces);
				int count = tuple ? replacement.ArgCount : 1;
				if (replacements.Count != count)
				{
					sink.Write(Severity.Error, replacement, "unroll, iteration {0}: Expected {1} replacement items, got {2}", iteration, replacements.Count, count);
					if (count < replacements.Count)
						continue; // too few
				}
				for (int i = 0; i < replacements.Count; i++)
					replacements.InternalArray[i].B = tuple ? replacement.Args[i] : replacement;

				if (body.Calls(S.Braces)) {
					foreach (LNode stmt in body.Args)
						output.Add(ctx.Replace(stmt).Value);
				} else
					output.Add(ctx.Replace(body).Value);
			}

			foreach (var r in replacements)
				if (r.C == 0 && !r.A.Name.StartsWith("_"))
					sink.Write(Severity.Warning, var, "Replacement variable '{0}' was never used", r.A);
			
			return body.With(S.Splice, output.ToVList());
		}

        private void AddSensingProbabilityButton_Click(object sender, RoutedEventArgs e)
        {
            TextBox stateTextBox = FindTextBoxSibling(sender, "SensedStateTextBox");
            TextBox sensedPerceptionTextBox = FindTextBoxSibling(sender, "SensedPerceptionTextBox");
            TextBox probabilityTextBox = FindTextBoxSibling(sender, "SensingProbabilityTextBox");
            Triplet<String, String, Double> tuple = new Triplet<string, string, double>(stateTextBox.Text, sensedPerceptionTextBox.Text, Double.Parse(probabilityTextBox.Text));

            ModelItem.Properties["SensingProbabilities"].Collection.Add(tuple);
            stateTextBox.Clear();
            sensedPerceptionTextBox.Clear();
            probabilityTextBox.Clear();
        }

 public static IEnumerable<Triplet> Where(int maxFactor, int minFactor = 1, int sum = 0)
 {
     var triplets = new List<Triplet>();
     for (int i = minFactor; i < maxFactor - 1; i++)
     {
         for (int j = i + 1; j < maxFactor; j++)
         {
             for (int k = j + 1; k <= maxFactor; k++)
             {
                 var triplet = new Triplet(i, j, k);
                 if (ShouldIncludeTriplet(sum, triplet))
                     triplets.Add(triplet);
             }
         }
     }
     return triplets;
 }

        static Triplet[] ParentChildRelationships(int a, int b, int c)
        {
            var p1 = new Triplet();
            p1.a = a - 2 * b + 2 * c;
            p1.b = 2 * a - b + 2 * c;
            p1.c = 2 * a - 2 * b + 3 * c;

            var p2 = new Triplet();
            p2.a = a + 2 * b + 2 * c;
            p2.b = 2 * a + b + 2 * c;
            p2.c = 2 * a + 2 * b + 3 * c;

            var p3 = new Triplet();
            p3.a = -a + 2 * b + 2 * c;
            p3.b = -2 * a + b + 2 * c;
            p3.c = -2 * a + 2 * b + 3 * c;

            return new Triplet[3] { p1, p2, p3 };
        }

    public static List<Triplet> Where(int maxFactor, int minFactor = 1)
    {
        List<Triplet> triplets = new List<Triplet>();

        for (int a = minFactor; a <= maxFactor; a++)
        {
            for (int b = a; b <= maxFactor; b++)
            {
                for (int c = b; c <= maxFactor; c++)
                {
                    Triplet triplet = new Triplet(a, b, c);
                    if (triplet.IsPythagorean())
                    {
                        triplets.Add(triplet);
                    };
                }
            }
        }
        return triplets;
    }

        protected virtual WebQueryAsyncResult ExecuteGetOrDeleteAsync(GetDeleteHeadOptions method, string url, object userState)
        {
            WebResponse = null;

            var request = BuildGetDeleteHeadOptionsWebRequest(method, url);
            var state = new Triplet<WebRequest, object, object>
                            {
                                First = request,
                                Second = null,
                                Third = userState
                            };

            var args = new WebQueryRequestEventArgs(url);
            OnQueryRequest(args);

            var inner = request.BeginGetResponse(GetAsyncResponseCallback, state);
            RegisterAbortTimer(request, inner); 
            var result = new WebQueryAsyncResult { InnerResult = inner };
            return result;
        }

        private Triplet<WebRequest, byte[], Pair<TimeSpan, int>> OnPostStreamQueryRequest(string url, WebRequest request, byte[] content, TimeSpan duration, int resultCount)
        {
            var state = new Triplet<WebRequest, byte[], Pair<TimeSpan, int>>
            {
                First = request,
                Second = content,
                Third = new Pair<TimeSpan, int>
                {
                    First = duration,
                    Second = resultCount
                }
            };

            var args = new WebQueryRequestEventArgs(url);
            OnQueryRequest(args);
            return state;
        }

        protected virtual WebQueryAsyncResult ExecutePostOrPutAsync(PostOrPut method,
                                                                    string url,
                                                                    IEnumerable<HttpPostParameter> parameters,
                                                                    object userState)
        {
            WebResponse = null;

            string boundary;
            var request = BuildMultiPartFormRequest(method, url, parameters, out boundary);

            var state = new Triplet<WebRequest, Pair<string, IEnumerable<HttpPostParameter>>, object>
                            {
                                First = request,
                                Second = new Pair<string, IEnumerable<HttpPostParameter>>
                                             {
                                                 First = boundary,
                                                 Second = parameters
                                             },
                                Third = userState
                            };
            var args = new WebQueryRequestEventArgs(url);

            OnQueryRequest(args);
            
            var inner = request.BeginGetRequestStream(PostAsyncRequestCallbackMultiPart, state);
            var result = new WebQueryAsyncResult { InnerResult = inner };
            RegisterAbortTimer(request, result);
            return result;
        }

 public PlayersTurn(Triplet _tripltetToTurn, bool _isClockwise)
 {
     TripltetToTurn = _tripltetToTurn;
     IsClockwise = _isClockwise;
 }

    private static void establishRemoteConnection(String strToIP, Triplet triplet, byte[] msg, int offset, int size)
    {
        Console.WriteLine("Boxit::establishRemoteConnection ENTER");

                                byte[] byteIP = {127, 0, 0, 1};
                                IPAddress ipAddress = new IPAddress(byteIP);
                                IPEndPoint ipEnd = new IPEndPoint (ipAddress, triplet.portNo);

                                Console.WriteLine("Boxit::establishRemoteConnection endPoint created");
                                //AsyncCallback beginConnectCallBack = new AsyncCallback(beginConnectCallBackFor_establishRemoteConnection);

                                Console.WriteLine("Boxit::establishRemoteConnection before calling Connect");
                                triplet.sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                                try
            {
                  triplet.sock.Connect(ipEnd);
            }
            catch (SocketException se)
            {
                Console.WriteLine("Connect SOCKET EXCEPTION!! ERROR CODE = {0}",se.ErrorCode);
                if(se.ErrorCode == 10056)
                    Console.WriteLine("10056: socket is already connected");
        //
                //throw se;

            }
                                Console.WriteLine("Boxit::establishRemoteConnection connect DONE");

                                SocketFlags f = new SocketFlags();
                                triplet.sock.BeginSend(msg, 0, msg.Length, f, null, null);
    }

    /// <summary>
    /// Returns the Triplet{width, height, radius} with coordinates containnig respictive width and height of the image
    /// </summary>
    /// <returns>Triplet{width, height, radius}</returns>
    public static Triplet<int, int, int> GetImageSize(ImageType type)
    {
        GlobalData gd = new GlobalData("");
        int thumbnailSize = gd.GetIntegerValue("ThumbnailSize");
        int previewSize = gd.GetIntegerValue("PreviewSize");
        int thumbnailSizeSmall = gd.GetIntegerValue("ThumbnailSizeSmall");//110 gd.GetIntegerValue("ThumbnailSize");
        int thumbnailSizeSlideShow = gd.GetIntegerValue("ThumbnailSizeSlideShow");

        Triplet<int, int, int> dimensions;
        switch (type)
        {
            case ImageType.UserPreview: //1
                dimensions = new Triplet<int, int, int>(previewSize, previewSize, 0);
                break;
            case ImageType.UserThumbnail: //2
                dimensions = new Triplet<int, int, int>(thumbnailSize, thumbnailSize, 0);
                break;
            case ImageType.EventPreview: //3
                dimensions = new Triplet<int, int, int>(previewSize, previewSize, 0);
                break;
            case ImageType.EventThumbnail: //4
                dimensions = new Triplet<int, int, int>(thumbnailSize, thumbnailSize, 0);
                break;
            case ImageType.EventCommentPreview: //5
                dimensions = new Triplet<int, int, int>(previewSize, previewSize, 0);
                break;
            case ImageType.EventCommentThumbnail: //6
                dimensions = new Triplet<int, int, int>(thumbnailSize, thumbnailSize, 0);
                break;
            case ImageType.EventPicturePreview: //7
                dimensions = new Triplet<int, int, int>(previewSize, previewSize, 0);
                break;
            case ImageType.EventPictureThumbnail: //8
                dimensions = new Triplet<int, int, int>(thumbnailSize, thumbnailSize, 0);
                break;
            case ImageType.EventPictureThumbnailSmall: //13
                dimensions = new Triplet<int, int, int>(thumbnailSizeSmall, thumbnailSizeSmall, 0);
                break;
            case ImageType.EventPictureThumbnailSlideShow: //14
                dimensions = new Triplet<int, int, int>(thumbnailSizeSlideShow, thumbnailSizeSlideShow, 0);
                break;
            default:
                dimensions = new Triplet<int, int, int>();
                break;
        }
        return dimensions;
    }

 private static bool ValidTriplet(Triplet triplet, int sum)
 {
     return triplet.IsPythagorean() && (triplet.Sum() == sum || sum == 0);
 }