private static int Gcdforparams(Algorythm algorythm, bool allowNegative, params int[] a)
{
ValidateArray(a);
if (Contains0Only(a))
{
throw new ArgumentOutOfRangeException("At least 1 number must be not 0");
}
if (!allowNegative)
{
if (!ContainsOnlyNonNegative(a))
{
throw new ArgumentOutOfRangeException("Numbers must be nonnegative");
}
}
int[] b = new int[a.Length];
Array.Copy(a, b, a.Length);
for (int i = b.Length - 2; i != -1; i--)
{
b[i] = algorythm(b[i], b[i + 1]);
}
return(b[0]);
}
private static int GcdforparamsPlusTime(out double time, Algorythm algorythm, bool allowNegative, params int[] a)
{
ValidateArray(a);
if (Contains0Only(a))
{
throw new ArgumentOutOfRangeException("At least 1 number must be not 0");
}
var sw = new Stopwatch();
sw.Start();
if (!allowNegative)
{
if (!ContainsOnlyNonNegative(a))
{
throw new ArgumentOutOfRangeException("Numbers must be nonnegative");
}
}
int[] b = new int[a.Length];
Array.Copy(a, b, a.Length);
for (int i = b.Length - 2; i != -1; i--)
{
b[i] = algorythm(b[i], b[i + 1]);
}
sw.Stop();
time = sw.Elapsed.TotalMilliseconds;
return(b[0]);
}
private static int Gcdfor3intsPlusTime(int a, int b, int c, Algorythm algorythm, bool allowNegative, out double time)
{
if (a == 0 && b == 0 && c == 0)
{
throw new ArgumentOutOfRangeException("At least 1 number must be not 0");
}
var sw = new Stopwatch();
sw.Start();
if (!allowNegative)
{
if (a < 0 || b < 0 || c < 0)
{
throw new ArgumentOutOfRangeException("Numbers must be nonnegative");
}
}
int k = algorythm(a, algorythm(b, c));
sw.Stop();
time = sw.Elapsed.TotalMilliseconds;
return(k);
}
public void WhenInputNotSorted_ReturnsSorted()
{
int[] input = { 1, 3, 5, 4, 7, 7, 2, 0, 4, 12 };
int[] expectedOutput = { 0, 1, 2, 3, 4, 4, 5, 7, 7, 12 };
var algorythm = new Algorythm();
var output = algorythm.Sort(input);
Assert.Equal(expectedOutput, output);
}
private void Canvas_OnMouseDown(object sender, MouseButtonEventArgs e)
{
if (StartPoint == null)
{
StartPoint = e.GetPosition(Canvas);
var x = (int)Math.Floor(StartPoint.Value.X / PixelSize);
var y = (int)Math.Floor(StartPoint.Value.Y / PixelSize);
Canvas.Children.Clear();
DrawGrid();
PutPixel(x, y);
}
else
{
EndPoint = e.GetPosition(Canvas);
}
if (StartPoint == null || EndPoint == null)
{
return;
}
var line = new Line
{
X1 = StartPoint.Value.X,
X2 = EndPoint.Value.X,
Y1 = StartPoint.Value.Y,
Y2 = EndPoint.Value.Y,
Stroke = Brushes.Red
};
var x0 = (int)Math.Floor(StartPoint.Value.X / PixelSize);
var y0 = (int)Math.Floor(StartPoint.Value.Y / PixelSize);
var x1 = (int)Math.Floor(EndPoint.Value.X / PixelSize);
var y1 = (int)Math.Floor(EndPoint.Value.Y / PixelSize);
var pixels = Algorythm.GetPixels(x0, y0, x1, y1);
foreach (var pixel in pixels)
{
PutPixel(pixel.X, pixel.Y);
}
Canvas.Children.Add(line);
this.Label.Content = string.Format("x0: {0}; y0: {1}; x1: {2}; y1:{3}",
x0, y0, x1, y1);
Canvas.Children.Add(this.Label);
StartPoint = null;
EndPoint = null;
}
static void Main(string[] args)
{
//для начала мы считываем данные со всех файлов, которые есть (они специально пронумерованы)
for (int i = 0; i < 100; i++)
{
string newTest = File.ReadAllText
(@"C:\Users\Варфоломеев\source\repos\Bellman_Ford\Generator\bin\Debug\"
+ i.ToString() + ".txt");
//переводим данные (они хорошо структурированны) в реальную матрицу
var test = TransformToMatrix(newTest);
Algorythm.BellmanFordAlgorythm(test.Length, test);
}
}
private static int Gcdfor3ints(int a, int b, int c, Algorythm algorythm, bool allowNegative)
{
if (a == 0 && b == 0 && c == 0)
{
throw new ArgumentOutOfRangeException("At least 1 number must be not 0");
}
if (!allowNegative)
{
if (a < 0 || b < 0 || c < 0)
{
throw new ArgumentOutOfRangeException("Numbers must be nonnegative");
}
}
int k = algorythm(a, algorythm(b, c));
return(k);
}
internal void Timer(Algorythm A)
{
DateTime dt1, dt2;
dt1 = DateTime.Now;
FindPrimes(A);
dt2 = DateTime.Now;
String intro = "";
switch (A)
{
case Algorythm.ISPRIME:
intro = "ISPRIME"; break;
case Algorythm.ERATHOSPHEN:
intro = "ERATHOSPHEN"; break;
case Algorythm.MODIFIED_ERATHOSPHEN:
intro = "MODIFIED_ERATHOSPHEN"; break;
case Algorythm.PARALLEL_ISPRIME_CYCLE:
intro = "PARALLEL_ISPRIME_CYCLE"; break;
case Algorythm.PARALLEL_ERATHOSPHEN11_DATA_DECOMPOSTION:
intro = "PARALLEL_ERATHOSPHEN11_DATA_DECOMPOSTION"; break;
case Algorythm.PARALLEL_ERATHOSPHEN12_CYCLE_DECOMPOSTION:
intro = "PARALLEL_ERATHOSPHEN12_CYCLE_DECOMPOSTION"; break;
case Algorythm.PARALLEL_ERATHOSPHEN2_PRIMEsSET_DECOMPOSTION:
intro = "PARALLEL_ERATHOSPHEN2_PRIMEsSET_DECOMPOSTION"; break;
case Algorythm.TASK_POOL:
intro = "TASK_POOL"; break;
case Algorythm.LOCK_SECTION:
intro = "LOCK_SECTION"; break;
}
primes = source.Where(x => res[Array.IndexOf(source, x)] == true).ToArray();
Console.WriteLine($@"{(dt2 - dt1).TotalMilliseconds: 0000.0000} ms took {intro} ");
}
public static Bitmap GetAnaglyphFromStereopair(Bitmap stereopair, Algorythm algorythm)
{
DevideStereopairOnTwoImages(stereopair);
StereoAnaglyph filter = new StereoAnaglyph();
filter.OverlayImage = rightImage;
switch (algorythm)
{
case Algorythm.ColorAnaglyph:
return filter.Apply(leftImage,
COLOR_ANAGLYPH_LEFT_IMAGE_FILTER_MATRIX,
COLOR_ANAGLYPH_RIGHT_IMAGE_FILTER_MATRIX);
case Algorythm.TrueAnaglyph:
return filter.Apply(leftImage,
TRUE_ANAGLYPH_LEFT_IMAGE_FILTER_MATRIX,
TRUE_ANAGLYPH_RIGHT_IMAGE_FILTER_MATRIX);
case Algorythm.OptimizedAnaglyph:
return filter.Apply(leftImage,
OPTIMIZED_ANAGLYPH_LEFT_IMAGE_FILTER_MATRIX,
OPTIMIZED_ANAGLYPH_RIGHT_IMAGE_FILTER_MATRIX);
case Algorythm.HalfColorAnaglyph:
return filter.Apply(leftImage,
HALF_COLOR_ANAGLYPH_LEFT_IMAGE_FILTER_MATRIX,
HALF_COLOR_ANAGLYPH_RIGHT_IMAGE_FILTER_MATRIX);
case Algorythm.GrayAnaglyph:
return filter.Apply(leftImage,
GRAY_ANAGLYPH_LEFT_IMAGE_FILTER_MATRIX,
GRAY_ANAGLYPH_RIGHT_IMAGE_FILTER_MATRIX);
default:
return filter.Apply(leftImage,
COLOR_ANAGLYPH_LEFT_IMAGE_FILTER_MATRIX,
COLOR_ANAGLYPH_RIGHT_IMAGE_FILTER_MATRIX);
}
}
internal void FindPrimes(Algorythm a)
{
switch (a)
{
case Algorythm.ISPRIME: SimplestSearch(); break;
case Algorythm.ERATHOSPHEN: Erathosphen(capacity); break;
case Algorythm.MODIFIED_ERATHOSPHEN: ModifiedErathosphen(capacity); break;
case Algorythm.PARALLEL_ISPRIME_CYCLE: ParallelIsPrimeCycle(capacity); break;
case Algorythm.PARALLEL_ERATHOSPHEN11_DATA_DECOMPOSTION: ParallelErathospen1_DataDecomposition(capacity); break;
case Algorythm.PARALLEL_ERATHOSPHEN12_CYCLE_DECOMPOSTION: ParallelErathospen_DataDecompositionCycle(capacity); break;
case Algorythm.PARALLEL_ERATHOSPHEN2_PRIMEsSET_DECOMPOSTION: ParallelErathospen_PrimesSetDecomposition(capacity); break;
case Algorythm.TASK_POOL: TaskPool(capacity); break;
case Algorythm.LOCK_SECTION: LockSection(capacity); break;
}
}
#pragma warning restore 1591
/// <summary>
/// Hashes a string using one of the sha algorithms - 1, 256 or 512
/// </summary>
/// <param name="s">Input string</param>
/// <param name="shaVersion">Version of the sha algorythm - Sha1, Sha256, Sha512; defaults to Sha1</param>
/// <param name="useBase64Encoding">Whether or not use base64 encoding for a returned string</param>
/// <returns>Hashed string</returns>
public static string ComputeShaHash(string s, Algorythm shaVersion, bool useBase64Encoding = false)
{
return(ComputeShaHash(s, (int)shaVersion, useBase64Encoding));
}
