void Iterative_OnComplete(ExpressionEventArgs sender)
{
TestToken token = sender.token as TestToken;
Iterative iterative = sender.term as Iterative;
Object.Equals(token.Id, "dummy");
}
public void ParallelOperator2()
{
var term1 = new TestTerm()
{
Id = "A"
};
var term2 = new TestTerm()
{
Id = "B"
};
var iterative1 = new Iterative(term1);
var iterative2 = new Iterative(term2);
var parallel = new Parallel(new List <Term>(new Term[] { iterative1, iterative2 }));
var tokenA = new TestToken()
{
Id = "A"
};
var tokenB = new TestToken()
{
Id = "B"
};
term1.OnComplete += Term1_OnComplete1;
term2.OnComplete += Term2_OnComplete1;
parallel.Fire(tokenA);
parallel.Fire(tokenA);
parallel.Fire(tokenB);
Assert.True(parallel.State == ExpressionState.Complete);
}
public void Factorial_should_return_same_result_for_all_implementations(int n)
{
var basicResult = BasicRecursion.Factorial(n);
var tailResult = TailRecursion.Factorial(n);
var iterrativeResult = Iterative.Factorial(n);
var enumerableResult = Enumerable.Factorial(n);
Assert.That(basicResult, Is.EqualTo(tailResult));
Assert.That(basicResult, Is.EqualTo(iterrativeResult));
Assert.That(basicResult, Is.EqualTo(enumerableResult));
}
public void IterativeOperator()
{
var term1 = new TestTerm
{
Id = "dummy"
};
var iterative = new Iterative(term1);
var token1 = new TestToken
{
Id = "dummy"
};
iterative.OnComplete += Iterative_OnComplete;
iterative.Fire(token1);
Assert.True(iterative.State == ExpressionState.Complete);
// execute the term more than once
iterative.Fire(token1);
Assert.True(iterative.State == ExpressionState.Complete);
}
public int IterativeTest()
{
return(Iterative.Factorial(N));
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
IGH_Goo goo = null;
Image image = new Image();
if (!DA.GetData(0, ref goo))
{
return;
}
if (!goo.TryGetImage(ref image))
{
return;
}
int mode = 0;
DA.GetData(1, ref mode);
double numValA = 0.5;
DA.GetData(2, ref numValA);
double numValB = 0.5;
DA.GetData(3, ref numValB);
int numValC = 1;
DA.GetData(4, ref numValC);
Filter filter = new Filter();
int[] indices = new int[] { 2, 3, 4 };
switch ((FilterModes)mode)
{
case FilterModes.Otsu:
filter = new Otsu();
ClearParameters(indices);
image.Filters.Add(new Otsu());
break;
case FilterModes.SIS:
filter = new SIS();
ClearParameters(indices);
image.Filters.Add(new SIS());
break;
case FilterModes.Bradley:
SetParameter(2, "B", "Brightness", "Brightness difference limit");
SetParameter(3, "S", "Size", "Window size");
SetParameter(4);
filter = new Bradley(numValA, (int)numValB);
image.Filters.Add(new Bradley(numValA, (int)numValB));
break;
case FilterModes.Iterative:
SetParameter(2, "M", "Minimum", "Minimum error value");
SetParameter(3, "T", "Threshold", "Threshold value");
SetParameter(4);
filter = new Iterative(numValA, numValB);
image.Filters.Add(new Iterative(numValA, numValB));
break;
case FilterModes.Nilback:
SetParameter(2, "C", "C", "Mean offset C");
SetParameter(3, "K", "K", "Parameter K");
SetParameter(4, "R", "Radius", "Filter convolution radius");
filter = new Nilback(numValA, numValB, numValC);
image.Filters.Add(new Nilback(numValA, numValB, numValC));
break;
case FilterModes.Sauvola:
SetParameter(2, "R", "R", "Dynamic range");
SetParameter(3, "K", "K", "Parameter K");
SetParameter(4, "R", "Radius", "Filter convolution radius");
filter = new Sauvola(numValA, numValB, numValC);
image.Filters.Add(new Sauvola(numValA, numValB, numValC));
break;
case FilterModes.WolfJolion:
SetParameter(2, "R", "R", "Dynamic range");
SetParameter(3, "K", "K", "Parameter K");
SetParameter(4, "R", "Radius", "Filter convolution radius");
filter = new WolfJolion(numValA, numValB, numValC);
image.Filters.Add(new WolfJolion(numValA, numValB, numValC));
break;
}
message = ((FilterModes)mode).ToString();
UpdateMessage();
DA.SetData(0, image);
DA.SetData(1, filter);
}
public void DisablingOperator()
{
var term1 = new TestTerm()
{
Id = "A"
};
var iterative1 = new Iterative(term1);
var term2 = new TestTerm()
{
Id = "B"
};
var iterative2 = new Iterative(term2);
var term3 = new TestTerm()
{
Id = "C"
};
var disabling = new Disabling(new List <Term>(new Term[] { iterative1, iterative2, term3 }));
var tokenA = new TestToken()
{
Id = "A"
};
var tokenB = new TestToken()
{
Id = "B"
};
var tokenC = new TestToken()
{
Id = "C"
};
// una sequenza di token A
disabling.Fire(tokenA);
disabling.Fire(tokenA);
// invio un token C e completo l'espressione
disabling.Fire(tokenC);
Assert.True(disabling.State == ExpressionState.Complete);
disabling.Reset();
// dopo un token B, l'espressione non accetta più A
disabling.Fire(tokenA);
disabling.Fire(tokenB);
disabling.Fire(tokenA);
Assert.True(disabling.State == ExpressionState.Error);
disabling.Reset();
//una sequenza di token A
disabling.Fire(tokenA);
disabling.Fire(tokenA);
disabling.Fire(tokenA);
disabling.Fire(tokenA);
// stop della prima iterazione con uno o più token B
disabling.Fire(tokenB);
disabling.Fire(tokenB);
Assert.True(iterative2.State == ExpressionState.Complete);
// stop della seconda iterazione con un token C
// invio un token C e completo l'espressione
disabling.Fire(tokenC);
Assert.True(disabling.State == ExpressionState.Complete);
}
