Algorithms

using System;

namespace Pfz.Threading
{
  /// <summary>
  /// Class that returns the value of DateTime.Now.Ticks when GetValue is called 
  /// but also guarantees that two calls will generate different values, even if
  /// they are done one just after the other.
  /// </summary>
  public static class TicksOrIncrement
  {
    private static readonly object fLock = new object();
    private static long fLastValue = DateTime.Now.Ticks;
    private static readonly Random fRandom = new Random();
		
    /// <summary>
    /// Gets a new DateTime.Now.Ticks value or a random incremented value if
    /// this is a call done at the same microsecond of the last one.
    /// </summary>
    public static long GetNext()
    {
      long ticks = DateTime.Now.Ticks;
			
      lock(fLock)
      {
        if (ticks <= fLastValue)
          ticks = fLastValue + 1 + fRandom.Next(1000);
				
        fLastValue = ticks;
      }
			
      return ticks;
    }
  }
}

harold aptroot wrote:

Btw, your swap work "oddly", I would expect to swap by index and avoid ref hacks, but w/e.

harold aptroot wrote:

see if your value is smaller than the current root, and if so, return and go the other way instead (recursively)

harold aptroot wrote:

(btw, are you going to do A* with it? Heap is a good choice for A* IME)

CaptainSeeSharp wrote:

I'm not quite sure what you mean. Are you saying bounds back and forth between the first and last, then second to first, then second to last, ect...?

harold aptroot wrote:

I didn't need that feature (searching by value) in my A* implementation. Why do you need it?

if((dist(a,b)^2-RadiusSqrd)<0)
{
//inside circle might be a collision canidate
}

public static int blah(point P, point Q)//IComparer
{
     if(P.X>Q.x){ return 1;}
     else if(P.X==Q.x){return 0}
     else{return-1}
}