Exemplo n.º 1
0
		/// <summary>
		/// Generate in memory.
		/// </summary>
		/// <returns></returns>
		static List<Segment> GenerateList()
		{
			/// The whole bunch, or the next bunch, of segments.
			AllSegments = new List<Segment>();
			/// Start with this.
			/// (Todo: Perhaps read from the database.)
			long nextAvailableValue = 1L;

			for (int iteration = 0; iteration < ParametersOfExperiment.NoMoreIterationsThan; iteration++) {
				// Create the next segment.
				Segment s = new Segment().CreateNewSegmentOfRandomSize(nextAvailableValue,
					ParametersOfExperiment.MaxSegmentSize, ParametersOfExperiment.NoLargerValueThan);
				AllSegments.Add(s);

				// Split zero or more segments.
				int numberOfSplits = R.Next(0, ParametersOfExperiment.MaxNumberOfConsecutiveSplits);
				for (int split = 0; split < numberOfSplits; split++) {
					// Choose a random segment, split it, and update the list of segments.
					int xSegmentToSplit = R.Next(1, AllSegments.Count);
					AllSegments.SplitSegment(xSegmentToSplit);
				}

				// Stop if reached the max value.
				nextAvailableValue += s.Size;
				if (nextAvailableValue > ParametersOfExperiment.NoLargerValueThan) { break; }

			}

			return AllSegments;
		}
Exemplo n.º 2
0
		public void TestSegment()
		{
			Segment s;

			s = new Segment();
			Assert.IsFalse(s.IsValid);			

			s.CreateWithEndPoints(3, 2);
			Assert.IsFalse(s.IsValid);
			Assert.IsFalse(s.Size > 0);

			s.CreateWithEndPoints(7, 7);
			Assert.IsTrue(s.IsValid);
			Assert.AreEqual(1, s.Size);

			int size = int.MaxValue; // heh
			s.CreateWithEndPoints(1, size);
			Assert.IsTrue(s.IsValid);
			Assert.AreEqual(size, s.Size);

			// CreateNextSegmentOfRandomSize
			// TODO

		}
Exemplo n.º 3
0
		/// <summary>
		/// The segment is split into two.
		/// Left part is corrected (the split point is the new right end);
		/// right part is appended (the split point is the new left end).
		/// Null on an error!
		/// </summary>
		public static List<Segment> SplitSegment(this List<Segment> list, int indexOfSegmentToSplit)
		{
			if (null == list || indexOfSegmentToSplit >= list.Count) { return null; }

			Segment s = list[indexOfSegmentToSplit];
			if (s.Size == 1) { return list; } // cannot split

			int splitAt = R.Next(0, (int) (s.Right - s.Left)); // size is expected to fit in int

			// L..R is split as S. This means:
			// 1) if S < R, let T = S+1. Then:
			//    one segment is L..S
			//    another is T..R
			// 2) Otherwise, S=R. Let U = S-1 = R-1. Then:
			//    one segment is L..U
			//    another is R..R
			Segment sAnother = new Segment();

			long pointL = s.Left;
			long pointR = s.Right;

			long pointS, pointT, pointU;
			pointS = pointL + splitAt;

			if (splitAt < s.Size) {
				pointT = pointS + 1L;
				sAnother.CreateWithEndPoints(pointT, pointR);
				s.CreateWithEndPoints(pointL, pointS);
			} else {
				pointU = pointR - 1;
				sAnother.CreateWithEndPoints(pointR, pointR);
				s.CreateWithEndPoints(pointL, pointU);
			}

			// Replace s; add sAnother.
			list[indexOfSegmentToSplit] = s;
			list.Add(sAnother);

			return list;
		}