public void Test_IsEmpty_Count_OnCreation()
{
var seq = new SequentialSearch <Byte, Char>();
Assert.True(seq.IsEmpty);
Assert.Equal(0, seq.Count);
}
public void Search(int[] data, int value, int expected)
{
var search = new SequentialSearch(data);
var idx = search.Search(value);
Assert.AreEqual(expected, idx);
}
public void Setup()
{
this.sequentialSearch = new SequentialSearch();
this.arrayGenerator = new ArrayGenerator();
this.arrayGenerator.AscendGenerator(this.Length);
this.testArray = this.arrayGenerator.output;
}
public void Test_Add_Get()
{
var seq = new SequentialSearch <Byte, Char>();
seq.Add(1, 'A');
Assert.Equal('A', seq.Get(1));
}
public void SequenSearchTest2()
{
var list = new List <int>()
{
89, 45, 68, 90, 100, 29, 34, 17, 55
};
Assert.Equal(-1, SequentialSearch.Search(list, 99));
}
public void Test_Delete()
{
var seq = new SequentialSearch <Byte, Char>();
seq.Add(1, 'A');
seq.Delete(1);
Assert.False(seq.Contains(1));
}
public Hashtable(int m)
{
this.m = m;
ss = new SequentialSearch <K, V> [m];
for (int i = 0; i < m; i++)
{
ss[i] = new SequentialSearch <K, V>();
}
}
public void Test_Contains()
{
var seq = new SequentialSearch <Byte, Char>();
seq.Add(1, 'A');
seq.Add(2, 'B');
Assert.True(seq.Contains(1));
Assert.True(seq.Contains(2));
}
public void SequentialSerchTest()
{
// Arrange
var sequentialSearch = new SequentialSearch();
// Act
var index = sequentialSearch.DoSearch(number, array);
// Assert
Assert.AreEqual(EXPECTED_INDEX, index);
}
private SequentialSearch <Byte, Char> CreateFullSequencialSearch()
{
SequentialSearch <Byte, Char> seq = new SequentialSearch <Byte, Char>();
seq.Add(1, 'A');
seq.Add(2, 'B');
seq.Add(3, 'C');
seq.Add(4, 'D');
seq.Add(5, 'E');
seq.Add(6, 'F');
return(seq);
}
static void Main(string[] args)
{
System.AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionTrapper;
bool optionChosen = true;
while (optionChosen)
{
string option = Options.ChooseTopic();
while (!int.TryParse(option, out _) || int.Parse(option) < 1 || int.Parse(option) > 26)
{
Console.WriteLine("Invalid option.");
option = Console.ReadLine();
}
optionChosen = option switch
{
"1" => SinglyLinkedListSample.Sample(),
"2" => DoublyLinkedListSample.Sample(),
"3" => ArraySamples.SingleDimensionalArrays(),
"4" => ArraySamples.MultidimensionalArrays(),
"5" => ArraySamples.JaggedArrays(),
"6" => ArraySamples.ArrayListClass(),
"7" => BubbleSort.SortSample(),
"8" => SelectionSort.SortSample(),
"9" => InsertionSort.SortSample(),
"10" => ShellSort.SortSample(),
"11" => MergeSort.SortSample(),
"12" => HeapSort.SortSample(),
"13" => QuickSortSample.SortSample(),
"14" => CountingSort.SortSample(),
"15" => RadixSortSample.SortSample(),
"16" => BucketSortSample.SortSample(),
"17" => SequentialSearch.SearchSample(),
"18" => BinarySearchSample.SearchSample(),
"19" => TestBinarySearchTree(),
"20" => BreadthFirstSearchSample.SearchSample(),
"21" => DepthFirstSearchSample.SearchSample(),
"22" => FibonacciSample.Run(),
"23" => AnagramSample.Run(),
"24" => PalindromeSample.Run(),
"25" => Euclidean.Run(),
_ => false,
};
Console.ReadKey();
}
}
public void Test_Get_KeyNotFoundException()
{
var seq = new SequentialSearch <Byte, Char>();
Assert.Throws <KeyNotFoundException>(() => seq.Get(100));
}
public static void Main(string[] args)
{
string cmd = null;
string basename = null;
string inputdir = null;
string listfiles = null;
string extension = null;
string searchalg = "galloping";
string interalg = "in-order-tree";
OptionSet op = new OptionSet () {
{"help", "Show help", (v) => cmd = "help"},
{"build", "Build an index", (v) => cmd = "build"},
{"dir=", "Directory to scan", (v) => inputdir = v},
{"list=", "List of filenames (one per line)", (v) => listfiles = v},
{"ext=", "Valid extension", (v) => extension = v},
{"search", "Search for a query in an index", (v) => cmd = "search"},
{"index=", "Base name for the index (build or search)", (v) => basename = v},
{"search-algorithm=", "Choose the search algorithm (sequential|binary-search|galloping|backward-galloping)",
(v) => searchalg = v},
{"intersection-algorithm=", "Choose an intersection algorithm (sequential|svs|small-adaptive|barbay-sequential|barbay-randomized|in-order-tree)",
(v) => interalg = v}
};
var Largs = op.Parse (args);
if (Largs.Count > 0) {
Console.WriteLine ("Unknown arguments, valid options:");
op.WriteOptionDescriptions (Console.Out);
return;
}
var seq = new SeqTextIR ();
switch (cmd) {
case "build":
if (inputdir == null && listfiles == null) {
goto default;
}
if (basename == null) {
goto default;
}
// var seq_builder = SequenceBuilders.GetGolynskiSucc (12);
//var seq_builder = SequenceBuilders.GetSeqXLB_SArray64 (12);
var seq_builder = SequenceBuilders.GetSeqXLB_DiffSetRL64 (12, 31, new EliasDelta64 ());
//var seq_builder = SequenceBuilders.GetSeqXLB_DiffSetRL2_64 (12, 31, new EliasDelta64 ());
Console.WriteLine ("*** building SeqTextIR instance over {0} | filter {1}", inputdir, extension);
//var seq_container = new List<int>();
using (var seq_container = new SepDiskList32<int>(basename + ".memdata", 1<<12)) {
//var seq_container = new MemoryMappedList<int>("H", false); // false);
if (listfiles == null) {
seq.Build (GetFilenames (inputdir, extension), seq_builder, seq_container);
} else {
seq.Build (File.ReadAllLines (listfiles), seq_builder, seq_container);
}
}
Console.WriteLine ("*** saving");
seq.Save (basename);
/*{
string filename;
int sp;
int len;
Console.WriteLine ();
File.WriteAllText ("out-test-docid-0", seq.GetFileData (0, out filename, out sp, out len));
Console.WriteLine ("check file: {0}", filename);
}*/
break;
case "search":
if (basename == null) {
goto default;
}
ISearchAlgorithm<int> salg = null;
switch (searchalg.ToLower ()) {
case "galloping":
salg = new DoublingSearch<int> ();
break;
//case "backward-galloping":
// salg = new BackwardDoublingSearch();
// break;
case "binary-search":
salg = new BinarySearch<int> ();
break;
case "sequential":
salg = new SequentialSearch<int> ();
break;
default:
Console.WriteLine ("Unknown search algorithm: {0}", searchalg);
ShowHelp (op, cmd);
return;
}
IIntersection<int> ialg = null;
switch (interalg.ToLower ()) {
case "svs":
ialg = new SvS<int> (salg);
break;
case "small-adaptive":
ialg = new SmallAdaptive<int> (salg);
break;
case "barbay-sequential":
ialg = new BarbaySequential<int> (salg);
break;
case "barbay-randomized":
ialg = new BarbayRandomized<int> (salg);
break;
case "baeza-yates":
ialg = new BaezaYatesIntersection<int> (salg);
break;
case "in-order-tree":
ialg = new InOrderUnbalancedTreeIntersection<int> (0.5, salg);
break;
case "sequential":
throw new NotImplementedException ("sequential intersection is not supported. Instead use svs + sequential search");
default:
ShowHelp (op, cmd);
return;
}
seq.Load (basename);
while (true) {
Console.WriteLine ("query [enter]");
string query = Console.ReadLine ();
if (query == null || query == "") {
break;
}
Search (seq, query, ialg);
}
break;
case "help":
default:
ShowHelp (op, cmd);
break;
}
}
