public void TestSatisfy()
{
var r = Prim.Satisfy(c => c == 'x', "'x'").Parse("xbxcxdxe").Value.Single();
Assert.True(r.Item1.Value == 'x');
Assert.True(r.Item2.AsString() == "bxcxdxe");
}
public void TestMany()
{
var r = Prim.Many(Prim.Character('a')).Parse("aaabcde").Value.Single();
Assert.True(r.Item1.AsString() == "aaa");
Assert.True(r.Item2.AsString() == "bcde");
}
public void PrimWithGraph()
{
char[] vertices = new char[] { 'a', 'b', 'c', 'd' };
List <(int weight, char u, char v)> actualResult = new List <(int weight, char u, char v)>();
actualResult.Add((1, 'a', 'b'));
actualResult.Add((1, 'd', 'c'));
actualResult.Add((2, 'b', 'd'));
Prim <char> prim = new Prim <char>(vertices);
prim.AddEdge(1, 'a', 'b');
prim.AddEdge(5, 'a', 'c');
prim.AddEdge(3, 'a', 'd');
prim.AddEdge(4, 'b', 'c');
prim.AddEdge(2, 'b', 'd');
prim.AddEdge(1, 'c', 'd');
List <(int weight, char u, char v)> result = prim.ExecutePrim('a');
Assert.Equal(3, result.Count);
for (int i = 0; i < result.Count; i++)
{
Assert.Equal(actualResult[i], result[i]);
}
}
private void TestMstAlgorithm(IWeightedGraph <int, double> graph, double expectedMstWeight, double precision, ALGORITHM algorithm)
{
// Build minimum spanning tree with algorithm to test
IWeightedGraph <int, double> msp;
switch (algorithm)
{
case ALGORITHM.KRUSKAL:
msp = Kruskal.FindMinimumSpanningTree(graph);
break;
case ALGORITHM.PRIM:
msp = Prim.FindMinimumSpanningTree(graph, 0, double.MaxValue);
break;
default:
throw new NotImplementedException($"No minimum spanning tree test implemented for algorithm {algorithm.ToString()}.");
}
// Check that all verteces are included
Assert.AreEqual(graph.VertexCount, msp.VertexCount);
// Count edges and compute total weight
IEnumerable <IWeightedEdge <int, double> > edges = msp.GetAllEdges();
int edgeCount = edges.Count();
double mspWeight = edges.Sum(e => e.Weight);
// Check edge count
Assert.AreEqual(graph.VertexCount - 1, edgeCount);
// Check that the total weight is as expected
AssertDoublesNearlyEqual(expectedMstWeight, mspWeight, precision);
}
public InCommentMulti(LanguageDef def)
:
base(
inp =>
{
int depth = 1;
while (depth > 0)
{
var res = Prim.String(def.CommentEnd).Parse(inp);
if (!res.IsFaulted)
{
depth--;
inp = res.Value.Head().Item2;
continue;
}
res = Prim.String(def.CommentStart).Parse(inp);
if (!res.IsFaulted)
{
depth++;
inp = res.Value.Head().Item2;
continue;
}
var resU = Prim.SkipMany(Prim.NoneOf(def.CommentStartEndDistinctChars.Value)).Parse(inp);
if (resU.Value.Head().Item2.IsEmpty)
{
return(Prim.Failure <Unit>(ParserError.Create("end of comment", inp)).Parse(inp));
}
inp = resU.Value.Head().Item2;
}
return(Prim.Return <Unit>(Unit.Default).Parse(inp));
})
{
}
public void TestWhiteSpace()
{
var r = Prim.WhiteSpace().Parse(" ");
Assert.False(r.IsFaulted);
Assert.True(r.Value.Count() == 1);
}
public Octal()
:
base(
inp =>
{
var r = (from x in Prim.Character('o').Or(Prim.Character('O'))
from d in Prim.Many1(Prim.OctalDigit())
select d)
.Parse(inp);
if (r.IsFaulted)
{
return(ParserResult.Fail <IntegerToken>(r.Errors));
}
else
{
var val = r.Value.First();
return(ParserResult.Success <IntegerToken>(
Tuple.Create(
new IntegerToken(Convert.ToInt32(val.Item1.AsString(), 8), inp.First().Location),
val.Item2
).Cons()
));
}
}
)
{ }
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
int n = Int32.Parse(inputLabel.Text);
int tmp;
if ((n - 1) % 2 == 0)
{
tmp = n - 2;
}
else
{
tmp = n - 1;
}
for (int i = tmp; i >= 2; i -= 2)
{
if (worker.CancellationPending == true)
{
e.Cancel = true;
break;
}
if (Prim.IsPrim1(i))
{
worker.ReportProgress(i);
break;
}
Thread.Sleep(200);
worker.ReportProgress(i);
}
}
private void btnPrim_Click(object sender, EventArgs e)
{
this.ResetResolucion();
this.resolucion = Prim.Ejecutar(g);
this.Dibujar();
this.ImprimirResultado();
}
private void btnChayTuDong_Click(object sender, EventArgs e)
{
if (Check())
{
// kiểm tra time delay
int timeDelay = 0;
try
{
timeDelay = Int32.Parse(txtDelay.Text);
if (timeDelay < 0)
{
MessageBox.Show("Time delay phải là số nguyên dương", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
catch
{
MessageBox.Show("Time delay phải là số nguyên dương", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
btnTamDung.Enabled = true;
btnKetThuc.Enabled = true;
btnBatDauChayTungBuoc.Enabled = false;
listDoThi = Prim.Run(Data.Data.graph_Prim);
index = 0;
timer.Enabled = true;
timer.Interval = timeDelay;
timer.Start();
return;
}
}
private void btnKaydet_Click(object sender, EventArgs e)
{
double a;
if (Double.TryParse(txtTutar.Text, out a) && Convert.ToInt32(txtTutar.Text) > 0 && txtPersonelID.Text != "" && txtDonem.Text != "")
{
Prim p = new Prim();
p.PersonelID = Convert.ToInt32(txtPersonelID.Text);
p.PrimTutar = Convert.ToDouble(txtTutar.Text);
p.Donem = txtDonem.Text;
if (p.PrimEkle(p))
{
MessageBox.Show("Prim eklendi.");
Temizle();
btnDegistir.Enabled = false;
btnSil.Enabled = false;
btnKaydet.Enabled = false;
}
else
{
MessageBox.Show("Prim eklenemedi.");
}
}
else
{
MessageBox.Show("Lütfen kutuları doğru değerler ile doldurunuz.");
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
Job hello = new Job(23, 23);
JobFileReader fileReader = new JobFileReader();
(int, Job[])myJobData = fileReader.ReadJobFile(@"C:\Users\Paul\Documents\Open Source Society for Computer Science (OSSU)\Algorithms Coursera\Programming Assignments\Week 9 Programming Assignment\TestCases\Test Case 1.txt");
JobScheduler jobScheduler = new JobScheduler();
Job[] gg = jobScheduler.DifferenceCriterion(myJobData.Item2);
foreach (Job j in gg)
{
Console.WriteLine(j._jobValue);
}
Console.WriteLine("---------------------------");
Week9FileReader fileReader2 = new Week9FileReader();
Dictionary <int, List <(int?, int)> > adjacentGraph = fileReader2.GraphFileReader(@"C:\Users\Paul\Documents\Open Source Society for Computer Science (OSSU)\Algorithms Coursera\Programming Assignments\Week 9 Programming Assignment with DLL\Assignment9\MST Data.txt");
Prim prim = new Prim();
Graph graph = new Graph(adjacentGraph);
Console.WriteLine("");
List <Edge> tree = prim.Apply(graph, graph._vertices[1]);
int myAnswer = 0;
foreach (Edge ed in tree)
{
myAnswer += ed._length;
}
Console.WriteLine("MST Length: " + myAnswer);
Console.ReadKey();
}
private void btnBatDauChayTungBuoc_Click(object sender, EventArgs e)
{
if (btnBatDauChayTungBuoc.Text == "Bắt đầu chạy từng bước")
{
if (Check())
{
listDoThi = Prim.Run(Data.Data.graph_Prim);
index = 0;
HienThiDoThi();
btnChayTuDong.Enabled = false;
btnPrev.Enabled = true;
btnNext.Enabled = true;
btnStart.Enabled = true;
btnEnd.Enabled = true;
btnBatDauChayTungBuoc.Text = "Kết thúc chạy từng bước";
}
return;
}
if (btnBatDauChayTungBuoc.Text == "Kết thúc chạy từng bước")
{
btnBatDauChayTungBuoc.Text = "Bắt đầu chạy từng bước";
btnChayTuDong.Enabled = true;
btnPrev.Enabled = false;
btnNext.Enabled = false;
btnStart.Enabled = false;
btnEnd.Enabled = false;
return;
}
}
public void TestCase4ShouldPass()
{
//var textreader = new StreamReader(typeof(PrimTests).Assembly.GetManifestResourceStream("Tests.largeEWG.txt"));
var result = Prim.Run(File.ReadLines("c:\\work\\largeEWG.txt"));//GetLines(textreader));
Assert.AreEqual(new Decimal(647.66306955), result);
}
public void TestDigitList()
{
var p = from open in Prim.Character('[')
from d in Prim.Digit()
from ds in
Prim.Many(
from comma in Prim.Character(',')
from digit in Prim.Digit()
select digit
)
from close in Prim.Character(']')
select d.Cons(ds);
var r = p.Parse("[1,2,3,4]").Value.Single();
Assert.True(r.Item1.First().Value == '1');
Assert.True(r.Item1.Skip(1).First().Value == '2');
Assert.True(r.Item1.Skip(2).First().Value == '3');
Assert.True(r.Item1.Skip(3).First().Value == '4');
var r2 = p.Parse("[1,2,3,4");
Assert.True(r2.IsFaulted);
Assert.True(r2.Errors.First().Expected == "']'");
Assert.True(r2.Errors.First().Input.IsEmpty);
var r3 = p.Parse("[1,2,3,4*");
Assert.True(r3.IsFaulted);
Assert.True(r3.Errors.First().Expected == "']'");
Assert.True(r3.Errors.First().Location.Line == 1);
Assert.True(r3.Errors.First().Location.Column == 9);
}
public void TestBetween()
{
var r = Prim.Between(Prim.Character('['), Prim.Character(']'), Prim.String("abc")).Parse("[abc]");
Assert.True(!r.IsFaulted);
Assert.True(r.Value.First().Item1.AsString() == "abc");
}
public ParseEsc(char c, char code)
:
base(
inp =>
{
var r = Prim.Character(c).Parse(inp);
if (r.IsFaulted)
{
return(r);
}
else
{
var tuple = r.Value.First();
return(ParserResult.Success <ParserChar>(
Tuple.Create <ParserChar, ImmutableList <ParserChar> >(
new ParserChar(
code,
tuple.Item1.Location
),
tuple.Item2
).Cons()
));
}
}
)
{ }
public void TopLevelParserTest()
{
//TODO: Test Parser
ScrapeQLParser parser = new ScrapeQLParser();
Parser <Query> top = parser.TopLevelParser();
Parser <ImmutableList <Query> > tops =
from qs in Prim.Many(top)
from _ in Prim.WhiteSpace()
select qs;
var result = tops.Parse("LOAD \"asda\" AS asdsd \n SELECT \"asdsd\" AS asdas FROM asds");
if (result.IsFaulted)
{
//Console.WriteLine("Error: " + result.Errors.First().Message);
//Console.WriteLine("Expected: " + result.Errors.First().Expected);
//Console.WriteLine("In Line: " + result.Errors.First().Location.Line + " In Column: " + result.Errors.First().Location.Column);
}
else
{
//Console.WriteLine(result.Value.First().Item1.ParsedObjectDisplayString());
foreach (Query q in result.Value.First().Item1)
{
//Console.WriteLine("HIT:" + q.ParsedObjectDisplayString());
}
}
Assert.Fail();
}
public ActionResult DeleteConfirmed(int id)
{
Prim prim = db.Prim.Find(id);
db.Prim.Remove(prim);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void PrimWithEmptyGraph()
{
char[] vertices = new char[] {};
Prim <char> prim = new Prim <char>(vertices);
List <(int weight, char u, char v)> result = prim.ExecutePrim('a');
Assert.Equal(0, result.Count);
}
public void DeberiaRetornarListaVaciaSiElGrafoEstaVacio()
{
var g = new Grafo();
var l = Prim.Ejecutar(g);
Assert.IsNotNull(l);
Assert.AreEqual(0, l.Count);
}
public Symbol(string name)
:
base(
inp => (from sym in Tok.Lexeme <ImmutableList <ParserChar> >(Prim.String(name))
select new SymbolToken(sym))
.Parse(inp)
)
{
}
public HaskellDef()
{
IdentLetter = IdentLetter.Or(Prim.Character('#'));
ReservedNames = Enumerable.Concat(
ReservedNames,
new string[] { "foreign", "import", "export", "primitive"
, "_ccall_", "_casm_"
, "forall" });
}
static void Main(string[] args)
{
var graph = new Graph <int>();
var nodes = new List <Node <int> >();
var edges = new List <Edge <int> >();
while (true)
{
Console.Write("Додати нову вершину?\n-> ");
if (Console.ReadLine() == "y")
{
nodes.Add(new Node <int>()
{
Value = 1 + nodes.Count
});
Console.WriteLine($"Додали вершину {nodes.Last().ToString()}");
}
else
{
break;
}
}
while (true)
{
Console.Write("Додати нове ребро?\n-> ");
if (Console.ReadLine() == "y")
{
Console.Write("Номер першої вершини\n-> ");
int node1Num = Int32.Parse(Console.ReadLine());
Console.Write("Номер другої вершини\n-> ");
int node2Num = Int32.Parse(Console.ReadLine());
Console.Write("Вага ребра\n-> ");
int weight = Int32.Parse(Console.ReadLine());
edges.Add(new Edge <int>()
{
Node1 = nodes[node1Num - 1],
Node2 = nodes[node2Num - 1],
Weight = weight
});
}
else
{
break;
}
}
graph.Nodes = nodes;
graph.Edges = edges;
Console.WriteLine("Алгоритм Краскала");
var res = Kruskal.Run(graph);
ShowCarcass(res);
Console.WriteLine("Алгоритм Прима");
var resprim = Prim.Run(graph);
ShowCarcass(resprim);
Console.ReadLine();
}
public WsChrParser(char c)
:
base(
inp => Prim.WhiteSpace()
.And(Prim.Character(c))
.Parse(inp)
)
{
}
public void TestReturn()
{
var r = Prim.Return(1).Parse("abc").Value.Single();
Assert.True(
r.Item1 == 1 &&
r.Item2.AsString() == "abc"
);
}
private static int RunPrim(Vertex[] vertices)
{
foreach (Vertex v in vertices)
{
v.Reset();
}
return(Prim.Run(vertices).Sum(e => e.Weight));
}
private static void PrimAlgorithmn()
{
List <Vertex> graph = new List <Vertex>();
Vertex a = new Vertex("A");
Vertex b = new Vertex("B");
Vertex c = new Vertex("C");
Vertex d = new Vertex("D");
Vertex e = new Vertex("E");
Edge ab = new Edge(2);
a.AddEdge(b, ab);
b.AddEdge(a, ab);
Edge ac = new Edge(3);
a.AddEdge(c, ac);
c.AddEdge(a, ac);
Edge bc = new Edge(2);
b.AddEdge(c, bc);
c.AddEdge(b, bc);
Edge be = new Edge(5);
b.AddEdge(e, be);
e.AddEdge(b, be);
Edge cd = new Edge(1);
c.AddEdge(d, cd);
d.AddEdge(c, cd);
Edge ce = new Edge(1);
c.AddEdge(e, ce);
e.AddEdge(c, ce);
graph.Add(a);
graph.Add(b);
graph.Add(c);
graph.Add(d);
graph.Add(e);
Console.WriteLine("****************");
Console.WriteLine("\n");
Prim MyPrimAlgo = new Prim(graph);
Console.WriteLine("Graph before Prim");
Console.WriteLine(MyPrimAlgo.OriginalGraphToString());
Console.ReadLine();
Console.WriteLine("Graph after Prim");
MyPrimAlgo.Run();
MyPrimAlgo.ResetPrintHistory();
Console.WriteLine(MyPrimAlgo.MinimumSpanningTreeToString());
Console.WriteLine("****************");
Console.WriteLine("\n");
Console.ReadLine();
}
internal override void WriteJsonSchema(Utf8JsonWriter writer)
{
writer.WriteString("type", "array");
writer.WriteStartObject("items");
Item.WriteJsonSchema(writer);
writer.WriteEndObject();
writer.WriteString("$comment", Prim.ToString());
}
public CharEscape()
:
base(
inp => (from c in Prim.Character('\\')
from ec in Tok.Chars.EscapeCode()
select ec)
.Parse(inp)
)
{
}
public void Init()
{
_graphBuilder = new PrimGraphBuilder("prim_hw.txt");
_graph = _graphBuilder.Build();
_prim = new Prim(_graph);
}
