Dataset for pretraining.

PySymGym · Oct 10, 2023 · 16e54f8 · 16e54f8
1 parent 79f1940
commit 16e54f8
Show file tree

Hide file tree

Showing 15 changed files with 21 additions and 18 deletions.
diff --git a/VSharp.ML.GameMaps/AStar.cs b/VSharp.ML.GameMaps/AStar.cs
@@ -1,7 +1,7 @@
 using NUnit.Framework;
 using VSharp.Test;
 
-[TestSvmFixture, Category("Dataset")]
+[TestSvmFixture,Category("Dataset")]
 class A_star
     {
         // Coordinates of a cell - implements the method Equals
@@ -229,6 +229,7 @@ public void ResetCell(Coordinates cell, List<Coordinates> coordinatesList)
         }
 
         // The main method
+        [TestSvm(expectedCoverage:50, serialize:"AStar"), Category("Dataset")]
         public static void AStarMain(Cell[,] field, int[,] walls)
         {
             Astar astar = new Astar(field, walls);

diff --git a/VSharp.ML.GameMaps/AhoCorasick.cs b/VSharp.ML.GameMaps/AhoCorasick.cs
@@ -176,7 +176,7 @@ static int findNextState(int currentState,
     // This function finds all occurrences of
     // all array words in text.
 
-    [TestSvm(100,serialize:"AhoCorasick.SearchWords"), Category("Dataset")]
+    [TestSvm(5,serialize:"AhoCorasick.SearchWords"), Category("Dataset")]
     public static List<Tuple<string, int, int>> SearchWords(String[] arr, int k,
                             String text)
     {

diff --git a/VSharp.ML.GameMaps/BellmanFord.cs b/VSharp.ML.GameMaps/BellmanFord.cs
@@ -28,7 +28,7 @@ class Edge {
     // src to all other vertices using Bellman-Ford
     // algorithm. The function also detects negative weight
     // cycle
-    [TestSvm(100,serialize:"BellmanFord"), Category("Dataset")]
+    [TestSvm(50,serialize:"BellmanFord"), Category("Dataset")]
     public int[] BellmanFord(Graph graph, int src)
     {
         int V = graph.V, E = graph.E;

diff --git a/VSharp.ML.GameMaps/BinaryMaze.cs b/VSharp.ML.GameMaps/BinaryMaze.cs
@@ -58,7 +58,7 @@ static bool isValid(int row, int col)
 
 // function to find the shortest path between
 // a given source cell to a destination cell.
-	[TestSvm(100,serialize:"BinaryMaze1BFS"), Category("Dataset")]
+	[TestSvm(70,serialize:"BinaryMaze1BFS"), Category("Dataset")]
 	public static int BinaryMaze1BFS(int [,]mat, Point src,
 						Point dest)
 {
@@ -188,7 +188,7 @@ static int findShortestPath(int[, ] mat, int i, int j,
 	}
 
 	// Wrapper over findShortestPath() function
-	[TestSvm(100,serialize:"findShortestPathLength"), Category("Dataset")]
+	[TestSvm(50,serialize:"findShortestPathLength"), Category("Dataset")]
 	public static int findShortestPathLength(int[, ] mat,
 									int[] src, int[] dest)
 	{

diff --git a/VSharp.ML.GameMaps/BinarySearch.cs b/VSharp.ML.GameMaps/BinarySearch.cs
@@ -49,7 +49,7 @@ static int numberOfPainters(int[] arr,
         return numPainters;
     }
 
-    [TestSvm(100,serialize:"bsPartition"), Category("Dataset")]
+    [TestSvm(20,serialize:"bsPartition"), Category("Dataset")]
     static public int bsPartition(int[] arr,
         int n, int k)
     {

diff --git a/VSharp.ML.GameMaps/BridgesInGraph.cs b/VSharp.ML.GameMaps/BridgesInGraph.cs
@@ -83,7 +83,7 @@ void bridgeUtil(int u, bool []visited, int []disc,
 
     // DFS based function to find all bridges. It uses recursive 
     // function bridgeUtil() 
-    [TestSvm()]
+    [TestSvm(expectedCoverage:50, serialize:"BridgesGraph"), Category("Dataset")]
     public void bridge() 
     { 
         // Mark all the vertices as not visited 

diff --git a/VSharp.ML.GameMaps/EulerCircuit.cs b/VSharp.ML.GameMaps/EulerCircuit.cs
@@ -145,6 +145,7 @@ Boolean isEulerianCycle()
 }
 
 // Driver code
+[TestSvm(expectedCoverage:50, serialize:"EulerMain"), Category("Dataset")]
 public static bool EulerMain(EulerGraph g)
 {
 	return g.isEulerianCycle();

diff --git a/VSharp.ML.GameMaps/Islands.cs b/VSharp.ML.GameMaps/Islands.cs
@@ -44,7 +44,7 @@ static void DFS(int[, ] M, int i, int j, int ROW,
         }
     }
 
-    [TestSvm(100,serialize:"countIslands"), Category("Dataset")]
+    [TestSvm(50,serialize:"countIslands"), Category("Dataset")]
     public static int countIslands(int[, ] M)
     {
         int ROW = M.GetLength(0);

diff --git a/VSharp.ML.GameMaps/KMPSearch.cs b/VSharp.ML.GameMaps/KMPSearch.cs
@@ -6,8 +6,8 @@ namespace VSharp.ML.GameMaps;
 [TestSvmFixture, Category("Dataset")]
 public class KMPSearch
 {
-    [TestSvm(100,serialize:"SearchKMP"), Category("Dataset")]
-    static List<int> SearchKMP(string pat, string txt)
+    [TestSvm(50,serialize:"SearchKMP"), Category("Dataset")]
+    public static List<int> SearchKMP(string pat, string txt)
     {
         List<int> result = new List<int>();
         int M = pat.Length;

diff --git a/VSharp.ML.GameMaps/LCS.cs b/VSharp.ML.GameMaps/LCS.cs
@@ -12,8 +12,8 @@ class LCS{
 
 // Method returns total ways to increase
 // LCS length by 1
-	[TestSvm(100,serialize:"waysToIncreaseLCSBy1"), Category("Dataset")]
-	static int waysToIncreaseLCSBy1(String str1,
+	[TestSvm(5,serialize:"waysToIncreaseLCSBy1"), Category("Dataset")]
+	public static int waysToIncreaseLCSBy1(String str1,
 								String str2)
 {
 	int m = str1.Length, n = str2.Length;

diff --git a/VSharp.ML.GameMaps/MatrixInverse.cs b/VSharp.ML.GameMaps/MatrixInverse.cs
@@ -41,7 +41,7 @@ public static void getCofactor(int [,]A, int [,]temp, int p, int q, int n)
 
 /* Recursive function for finding determinant of matrix.
 n is current dimension of [,]A. */
-	[TestSvm(100,serialize:"determinant"), Category("Dataset")]
+	[TestSvm(50,serialize:"determinant"), Category("Dataset")]
 	public static int determinant(int [,]A, int n)
 {
 	int D = 0; // Initialize result
@@ -68,7 +68,7 @@ public static int determinant(int [,]A, int n)
 }
 
 // Function to get adjoint of A[N,N] in adj[N,N].
-	[TestSvm(100,serialize:"adjoint"), Category("Dataset")]
+	[TestSvm(50,serialize:"adjoint"), Category("Dataset")]
 	public static void adjoint(int [,]A, int [,]adj)
 {
 	if (N == 1)
@@ -101,7 +101,7 @@ public static void adjoint(int [,]A, int [,]adj)
 
 // Function to calculate and store inverse, returns false if
 // matrix is singular
-	[TestSvm(100,serialize:"matrixInverse"), Category("Dataset")]
+	[TestSvm(5,serialize:"matrixInverse"), Category("Dataset")]
 	public static bool matrixInverse(int [,]A, float [,]inverse)
 {
 	// Find determinant of [,]A

diff --git a/VSharp.ML.GameMaps/MatrixMultiplication.cs b/VSharp.ML.GameMaps/MatrixMultiplication.cs
@@ -111,6 +111,7 @@ public static void initWithZeros(int[, ] a, int r, int c){
 	return result_matrix;
 }
 
+[TestSvm(50,serialize:"MatrixMultiplicationMain"), Category("Dataset")]
 public static int[,] MatrixMultiplicationMain (int[,] matrix_A, int[,] matrix_B) {
 
 	int[, ] result_matrix = multiply_matrix(matrix_A, matrix_B);

diff --git a/VSharp.ML.GameMaps/MatrixQuery.cs b/VSharp.ML.GameMaps/MatrixQuery.cs
@@ -6,7 +6,7 @@
 
 [TestSvmFixture, Category("Dataset")]
 class MatrixQuery {
-    [TestSvm(100,serialize:"MatrixQueryModifyMatrix"), Category("Dataset")]
+    [TestSvm(50,serialize:"MatrixQueryModifyMatrix"), Category("Dataset")]
     public static void MatrixQueryModifyMatrix(int[, ] mat)
     {
 

diff --git a/VSharp.ML.GameMaps/SudokuGenerator.cs b/VSharp.ML.GameMaps/SudokuGenerator.cs
@@ -112,7 +112,7 @@ bool unUsedInCol(int j,int num)
 
 	// A recursive function to fill remaining
 	// matrix
-	[TestSvm(100,serialize:"fillRemaining"), Category("Dataset")]
+	[TestSvm(50,serialize:"fillRemaining"), Category("Dataset")]
 	public bool fillRemaining(int i, int j)
 	{
 		// System.out.println(i+" "+j);

diff --git a/VSharp.ML.GameMaps/WordWrap.cs b/VSharp.ML.GameMaps/WordWrap.cs
@@ -12,7 +12,7 @@ class WordWrap
 
 // Function to find space optimized
 // solution of Word Wrap problem.
-	[TestSvm(100,serialize:"solveWordWrap"), Category("Dataset")]
+	[TestSvm(20,serialize:"solveWordWrap"), Category("Dataset")]
 	public static List<Tuple<int, int>> solveWordWrap(int[] arr, int n, int k)
 {
 	int i, j;