Algorithms

int all = intSelectorA | intSelectorB | intSelectorC | intSelectorD;

switch (all)
{
    case 0:
        return "!A!B!C!D";
    ....
    case 15:
        return "ABCD";
}

IL_003e: switch (IL_00c4, IL_00d8, IL_00ec, IL_0100, IL_0114, IL_0128, IL_0309, IL_013c, IL_0150, IL_0165, IL_017a, IL_018f, IL_01a4, IL_01b9, IL_01ce, IL_01e3, IL_01f8, IL_020d, IL_0222, IL_0237, IL_024c, IL_0261, IL_0276, IL_0309, IL_028b, IL_029d, IL_02af, IL_02c1, IL_02d3, IL_02e5, IL_02f7)

IL_00bf: br IL_0309

IL_00c4: ldloc.1
IL_00c5: ldloc.1
IL_00c6: ldc.i4.1
IL_00c7: ldc.i4.1
IL_00c8: ldstr "!DCBAE"
IL_00cd: callvirt instance class Test5Parameters/BigSwitchBoolIntString Test5Parameters/BigSwitchBoolIntString::SetValue(class Test5Parameters/BigSwitchBoolIntString,  bool,  int32,  string)
IL_00d2: stloc.2
IL_00d3: br IL_0314
...
all the other cases
...

uint v=0;
if (Is_A) v|=0x00000001;
if (Is_B) v|=0x00000002;
...

if (v==someValue1) {
   // handle most likely case
} else if (v==someValue2) {
   // handle second most likely case
}...

void Start()
{
	bool[] bools = new bool[] { true, false, true};
	string testCase = "Test case " + FindTestCase(bools);
}

int FindTestCase(bool[] bools)
{
	string arrayCode = BoolArrayToBinaryString(bools);
	foreach (string code in BoolArrayToBinaryStringPermuations(bools.Length))
		if (code == arrayCode)
			return Convert.ToInt32(code, 2);

	return -1; //ignore
}

string BoolArrayToBinaryString(bool[] bools)
{
	StringBuilder sb = new StringBuilder();
	foreach (bool b in bools)
		sb.Append(Convert.ToInt32(b));

	return sb.ToString();
}

IEnumerable BoolArrayToBinaryStringPermuations(int count)
{
	double max = Math.Pow(2, count);
	for (int i = 0; i < max; i++)
		yield return Convert.ToString(i, 2).PadLeft(count, '0');
}

RobCroll wrote:

Math.Pow(2, count)

List<string> ExcludedCases = new List<string> {"DCBAE", "!D!C!BAE", "DCB!A!E"};

List<string> t = PermutationsManager.MakeBigSwitch
(
    IsVerboseOutput: true,
    IsExcludesAsComments: true,
    PriorityStr: "DCBAE",
    ClassTitle: "Test5Params",
    Excludes: ExcludedCases
);

// sample auto-generated output
using System;
using BigSwitch_0_0;

public static class Test5Params
{
    // Test 5 parameters DCBAE
    // CodeProject article or tip in progress 
    public static BigSwitchBoolIntString BigSwitch3(bool D, bool C, bool B, bool A, bool E)
    {
        // better way to do this: look-up table ? bit-shifting ?
        int intSelector = (D ? 0 : 16) + (C ? 0 : 8) + (B ? 0 : 4) + (A ? 0 : 2) + (E ? 0 : 1);

        // data class for results
        BigSwitchBoolIntString resultData = new BigSwitchBoolIntString();
        // assume fail
        resultData.IsSuccess = false;

        switch (intSelector)
        {
            // case 0:
                // test case: D AND C AND B AND A AND E : All Values True
                // Console.WriteLine("True in case: #0");
                // return resultData.SetValue(true, 0, "DCBAE : All Values True");
                // break;
            case 1:
                // test case:  NOT D AND C AND B AND A AND E
                // Console.WriteLine("True in case: #1");
                return resultData.SetValue(true, 1, "!DCBAE");
                break;

            // ... more cases ...

            case 31:
                // test case:  NOT D AND  NOT C AND  NOT B AND  NOT A AND  NOT E : All Values False
                // Console.WriteLine("True in case: #31");
                return resultData.SetValue(true, 31, "!D!C!B!A!E : All Values False");
                break;
            default:
                throw new BigSwitchFailException("Error In: Test5 parameters : DCBAE : DateTime: ");
        }
    }
}

public static GraphicsPath StraightPath(Point from, Point to, Rectangle fromRect, Rectangle toRect)
{
    GraphicsPath path = new GraphicsPath();
    //if short distance then just add a return a single line path
    if (PointDistance(from, to) < 40)
    {
        path.AddLine(from, to);
        return path;
    }
    List<Point> outputPoints = new List<Point>(6);
    outputPoints.Add(from);
    List<Point> inputPoints = new List<Point>(6);
    inputPoints.Add(to);
    bool isReversed = from.X > to.X;
    //swivel points to they no longer intersect the two rectangles
    int direction = from.Y >= to.Y ? fromRect.Top : fromRect.Bottom;
    if (LineRectangleIntersection(fromRect, outputPoints[outputPoints.Count - 1], inputPoints[inputPoints.Count - 1]))
        outputPoints.Add(new Point(outputPoints[outputPoints.Count - 1].X, direction));
    direction = from.Y <= to.Y ? toRect.Top : toRect.Bottom;
    if (LineRectangleIntersection(toRect, outputPoints[outputPoints.Count - 1], inputPoints[inputPoints.Count - 1]))
        inputPoints.Add(new Point(inputPoints[inputPoints.Count - 1].X, direction));
    //reverse the input points and add to output points
    inputPoints.Reverse();
    outputPoints.AddRange(inputPoints);
    path.AddLines(outputPoints.ToArray());
    return path;
}
public static bool LineRectangleIntersection(Rectangle rect, Point p1, Point p2)
{
    //top
    if (LineSegmentIntersection(p1, p2, new Point(rect.Left, rect.Top), new Point(rect.Right, rect.Top)))
    {
        return true;
    }
    //bottom
    if (LineSegmentIntersection(p1, p2, new Point(rect.Left, rect.Bottom), new Point(rect.Right, rect.Bottom)))
    {
        return true;
    }
    //left
    if (LineSegmentIntersection(p1, p2, new Point(rect.Left, rect.Top), new Point(rect.Left, rect.Bottom)))
    {
        return true;
    }
    //right
    if (LineSegmentIntersection(p1, p2, new Point(rect.Right, rect.Top), new Point(rect.Right, rect.Bottom)))
    {
        return true;
    }
    // no intersection
    return false;
}
internal static bool LineSegmentIntersection(
    float Ax, float Ay,
    float Bx, float By,
    float Cx, float Cy,
    float Dx, float Dy)
{
    float distAB, theCos, theSin, newX, ABpos;
    //  Fail if either line segment is zero-length.
    if (Ax == Bx && Ay == By || Cx == Dx && Cy == Dy)
        return false;
    //  (1) Translate the system so that point A is on the origin.
    Bx -= Ax;
    By -= Ay;
    Cx -= Ax;
    Cy -= Ay;
    Dx -= Ax;
    Dy -= Ay;
    //  Discover the length of segment A-B.
    distAB = (float) Math.Sqrt(Bx * Bx + By * By);
    //  (2) Rotate the system so that point B is on the positive X axis.
    theCos = Bx / distAB;
    theSin = By / distAB;
    newX = Cx * theCos + Cy * theSin;
    Cy = Cy * theCos - Cx * theSin;
    Cx = newX;
    newX = Dx * theCos + Dy * theSin;
    Dy = Dy * theCos - Dx * theSin;
    Dx = newX;
    //  Fail if segment C-D doesn't cross line A-B.
    if (Cy < 0f && Dy < 0f || Cy >= 0f && Dy >= 0f)
        return false;
    //  (3) Discover the position of the intersection point along line A-B.
    ABpos = Dx + (Cx - Dx) * Dy / (Dy - Cy);
    //  Fail if segment C-D crosses line A-B outside of segment A-B.
    if (ABpos < 0f || ABpos > distAB)
        return false;
    //  Success.
    return true;
}

BillWoodruff wrote:

3. List set of rectangle pairs => all in rectangle array 'ra, which need to be 'connected' by 1-3 line segments.

BillWoodruff wrote:

Simplest case would be a straight line: two points; then three points for a path with one right-angle turn; and, finally four points for a path with two right-angle turns.

BillWoodruff wrote:

Where: intersections of lines are minimized.

// will compile .NET 4.0 Client
// rough sketch for Line 'primitive'
Public class ConnectingLine
{
   public Rectangle sourceRectangle { get; set; }
   public Rectangle sinkRectangle { get; set; }
   public List<Point> cPoints { get; set; }
}

// will compile .NET 4.0 Client
// rough sketch for Line Manager Class
public static class ConnectingLines
{
   // Line Collection
   static internal List<ConnectingLine> ConnectingLineList = new List<ConnectingLine>();

   // using automatic property initializers
   public static void Add(Rectangle r1, Rectangle r2, List<Point> lPts)
   {
     ConnectingLineList.Add(new ConnectingLine
     {
       sourceRectangle = r1, sinkRectangle = r2, cPoints = lPts
     });
   }
}

// 'hard-coded' simulation of a call to add a new connection ...
// case where a connection requires 4 points that define 3 lines
// stick this in a method and call it
// will compile .NET 4.0 Client. Execute in a method body and inspect results
  ConnectingLines.Add
  (
      new Rectangle (200, 200, 200, 200),
      new Rectangle (275, 500, 200, 200),
      new List<Point> {new Point (300,400), new Point(300,450), new Point(375, 450), new Point(375,500)}
  );

BillWoodruff wrote:

1. No two rectangles can be connected by more than one line between them, but every rectangle can be connected to all other rectangles it has not already connected to.