List <t> Search and sorting

 

 

Originally implemented through delegation. 0 0...

Code:

1. Public class Vector
2. {
3. Public double? R = NULL;
4. Public double? Theta = NULL;
6. Public double? Thetaradians
7. {
8. Get
9. {
10. Return (theta * Math. PI/180.0 );
11. }
12. }
14. Public vector (double? R, double? Theta)
15. {
17. If (r> 0)
18. {
19. R =-R;
20. Theta ++ = 180;
21. }
22. Theta = Theta %360;
24. R = R;
25. Theta = Theta;
26. }
28. /// <Summary>
29. /// Overload + operator
30. /// </Summary>
31. /// <Param name = "OP1"> </param>
    
32. /// <Param name = "OP2"> </param>
    
33. /// <Returns> </returns>
    
34. Public static vector operator + (vector OP1, vector OP2)
35. {
36. Try
37. {
38. Double newx = op1.r. Value * Math. Sin (op1.thetaradians. Value) + op2.r. Value * Math. Sin (op2.thetaradians. value );
39. Double newy = op1.r. Value * Math. Cos (op1.thetaradians. Value) + op2.r. Value * Math. Cos (op2.thetaradians. value );
41. Double newr = math. SQRT (newx * newx + newy * newy );
42. Double newtheta = math. atan2 (newx, newy) * 180.0/Math. Pi;
44. Return new vector (newr, newtheta );
45. }
46. Catch
47. {
48. Return new vector (null, null );
49. }
50. }
52. /// <Summary>
53. /// Overload-Operator
54. /// </Summary>
55. /// <Param name = "OP1"> </param>
    
56. /// <Returns> </returns>
    
57. Public static vector operator-(vector OP1)
58. {
59. Return new vector (-op1.r, op1.theta );
60. }
62. /// <Summary>
63. /// Overload-Operator
64. /// </Summary>
65. /// <Param name = "OP1"> </param>
    
66. /// <Param name = "OP2"> </param>
    
67. /// <Returns> </returns>
    
68. Public static vector operator-(vector OP1, vector OP2)
69. {
70. Return OP1 + (-OP2 );
71. }
73. /// <Summary>
    
74. /// Rewrite the tostring () Operator
75. /// </Summary>
    
76. /// <Returns> </returns>
    
77. Public override string tostring ()
78. {
79. String rstring = R. hasvalue? R. tostring (): "null ";
80. String thetastring = Theta. hasvalue? Theta. tostring (): "null ";
82. Return string. Format ("({0}, {1})", rstring, thetastring );
83. }
85. }
87. Class vectors: List <vector>
88. {
89. Public vectors ()
90. {
91. }
93. Public vectors (ienumerable <vector> initiaitems)
94. {
95. Foreach (vector in initiaitems)
96. {
97. Add (vector );
98. }
100. }
102. Public String sum ()
103. {
104. Stringbuilder sb = new stringbuilder ();
105. Vector currenpoint = new vector (0.0, 0.0 );
106. SB. append ("Origin ");
107. Foreach (vector in this)
108. {
109. SB. appendformat ("+ {0}", vector );
110. Currenpoint + = vector;
111. }
113. SB. appendformat ("= {0}", currenpoint );
114. Return sb. tostring ();
115. }
116. }
118. Public static class vectordelegates
119. {
120. // Sorting method
121. Public static int compare (vector X, vector y)
122. {
123. If (X. r> Y. R)
124. {
125. Return 1;
126. }
127. Else if (X. r <Y. R)
128. {
129. Return-1;
130. }
131. Else
132. {
133. Return 0;
134. }
135. }
136. // Search Method
137. Public static bool toprightquadrant (vector target)
138. {
139. If (target. Theta> = 0.0 & target. Theta <= 90.0)
140. {
141. Return true;
142. }
143. Else
144. {
145. Return false;
146. }
147. }
148. }
150. Class Program
151. {
152. Static void main (string [] ARGs)
153. {
154. Vectors route = new vectors ();
155. Route. Add (new vector (2.0, 90.0 ));
156. Route. Add (new vector (1.0, 180.0 ));
157. Route. Add (new vector (0.5, 45.0 ));
158. Route. Add (new vector (2.5, 315.0 ));
160. Console. writeline (route. sum ());
162. // Sort the delegate
163. Comparison <vector> sorter = new comparison <vector> (vectordelegates. Compare );
164. // Sort
165. Route. Sort (sorter );
167. Console. writeline (route. sum ());
169. // Search delegate
170. Predicate <vector> searcher = new predicate <vector> (vectordelegates. toprightquadrant );
171. // Search
172. Vectors toprightquadrantroute = new vectors (route. findall (Searcher ));
174. Console. writeline (toprightquadrantroute. sum ());
175. Console. readkey ();
176. }
177. }