static void Main(string[] args)
{
string input = "glob is I\nprok is V\npish is X\ntegj is L\nglob glob Silver is 34 Credits\nglob prok Gold is 57800 Credits\npish pish Iron is 3910 Credits\nhow much is pish tegj glob glob ?\nhow many Credits is glob prok Silver ?\nhow many Credits is glob prok Gold ?\nhow many Credits is glob prok Iron ?\nhow much wood could a woodchuck chuck if a woodchuck could chuck wood ?";
ParseInput parse = new ParseInput();
List <string> lines = parse.GetLineFromInput(input);
List <string> AliasLines = parse.GetAliaseFromLines(lines);
List <string> ComodityAliasLines = parse.GetComodityAliasLine(lines);
List <string> QuestionLines = parse.GetQuestionLines(lines);
AliasMap map = new AliasMap();
var Alias = new Dictionary <string, string>();
Alias = map.MakeAliases(AliasLines);
Dictionary <string, double> ComodityCost = new Dictionary <string, double>();
ComodityCost = parse.GetComodityCost(ComodityAliasLines, Alias);
List <string> result = parse.GetResult(QuestionLines, Alias, ComodityCost);
foreach (var res in result)
{
Console.WriteLine(res);
}
}
private ParseResult CreateResultWithEmptyValues()
{
string fileContent =
@"First;Second;Third
firstValue ThirdValue";
var columnSpec = new ColumnSpecification[] {
new ColumnSpecification {
Length = 10, Type = ColumnType.String
},
new ColumnSpecification {
Length = 4, Type = ColumnType.String
},
new ColumnSpecification {
Length = 10, Type = ColumnType.String
}
};
var parseInput = new ParseInput
{
ColumnSpecifications = columnSpec,
FlatFileContent = fileContent,
HeaderDelimiter = ";",
HeaderRow = HeaderRowType.Delimited
};
var options = new ParseOptions {
SkipRows = false
};
var result = FixedWidthFlatFileTask.Parse(parseInput, options);
return(result);
}
static IEnumerable <CommandExecutor> CreateCommandsFromResultLists(ParseInput input,
List <List <ParseRange> > rangeLists, IDictionary <ParseRange, ParseResult[]> groupedResults,
IEnumerable <Command> potentialCommands, IEnumerable <CommandExecutor> potentialPartialCommands,
bool commandsFiltered)
{
if (!rangeLists.Any())
{
if (!commandsFiltered)
{
return(Enumerable.Empty <CommandExecutor>());
}
rangeLists = new List <List <ParseRange> > {
new List <ParseRange>()
};
}
var query1 = from c in potentialCommands
from rangeList in rangeLists
let cmd = CreateCommand(input, c, rangeList, groupedResults)
select cmd;
var query2 = from c in potentialPartialCommands
from rangeList in rangeLists
let cmd = CreateCommand(input, c, rangeList, groupedResults)
select cmd;
return(query1.Union(query2).Where(x => x != null));
}
public void TestIndexedMzML()
{
// Get temp path for writing the test mzML
var tempFilePath = Path.GetTempPath();
Console.WriteLine(tempFilePath);
var testRawFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Data/small.RAW");
var parseInput = new ParseInput(testRawFile, null, tempFilePath, OutputFormat.IndexMzML);
RawFileParser.Parse(parseInput);
// Deserialize the mzML file
var xmlSerializer = new XmlSerializer(typeof(indexedmzML));
var testMzMl = (indexedmzML)xmlSerializer.Deserialize(new FileStream(
Path.Combine(tempFilePath, "small.mzML"), FileMode.Open, FileAccess.Read, FileShare.ReadWrite));
Assert.AreEqual("48", testMzMl.mzML.run.spectrumList.count);
Assert.AreEqual(48, testMzMl.mzML.run.spectrumList.spectrum.Length);
Assert.AreEqual("1", testMzMl.mzML.run.chromatogramList.count);
Assert.AreEqual(1, testMzMl.mzML.run.chromatogramList.chromatogram.Length);
Assert.AreEqual(2, testMzMl.indexList.index.Length);
Assert.AreEqual("spectrum", testMzMl.indexList.index[0].name.ToString());
Assert.AreEqual(48, testMzMl.indexList.index[0].offset.Length);
Assert.AreEqual("chromatogram", testMzMl.indexList.index[1].name.ToString());
Assert.AreEqual(1, testMzMl.indexList.index[1].offset.Length);
}
public void TestProfileMzml()
{
// Get temp path for writing the test mzML
var tempFilePath = Path.GetTempPath();
var testRawFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Data/small.RAW");
var parseInput = new ParseInput(testRawFile, null, tempFilePath, OutputFormat.MzML);
parseInput.NoPeakPicking = true;
RawFileParser.Parse(parseInput);
// Deserialize the mzML file
var xmlSerializer = new XmlSerializer(typeof(mzMLType));
var testMzMl = (mzMLType)xmlSerializer.Deserialize(new FileStream(
Path.Combine(tempFilePath, "small.mzML"), FileMode.Open, FileAccess.Read, FileShare.ReadWrite));
Assert.AreEqual("48", testMzMl.run.spectrumList.count);
Assert.AreEqual(48, testMzMl.run.spectrumList.spectrum.Length);
Assert.AreEqual("1", testMzMl.run.chromatogramList.count);
Assert.AreEqual(1, testMzMl.run.chromatogramList.chromatogram.Length);
Assert.AreEqual(48, testMzMl.run.chromatogramList.chromatogram[0].defaultArrayLength);
}
public static void Main(string[] args)
{
var input = ParseInput.ToArray("../../input").ToDoubles();
for (var i = 0; i < input.Length; i++)
{
var fuelForMass = Math.Floor(input[i] / 3) - 2;
var allFuel = fuelForMass;
while (fuelForMass > 0)
{
fuelForMass = Math.Floor(fuelForMass / 3) - 2;
allFuel += fuelForMass >= 0 ? fuelForMass : 0;
}
input[i] = allFuel;
}
var fuel = 0d;
foreach (var el in input)
{
fuel += el;
}
Console.WriteLine(fuel);
}
static CommandExecutor CreateCommand(ParseInput input, Command command, List <ParseRange> rangeList,
IDictionary <ParseRange, ParseResult[]> groupedResults)
{
if (command.Name == "Open Program")
{
int x = 10;
}
var argList = CreateCommand(input, rangeList, groupedResults, command.Parameters);
if (argList == null)
{
return(null);
}
// if any of the arguments is unspecified, offer some suggestions
if (argList.Any(x => !x.IsSpecified))
{
argList = CommandHistory.PredictUnspecifiedArguments(command, argList);
if (argList.Where((t, i) => !t.IsSpecified && !command.Parameters[i].Optional).Any())
{
return(null);
}
}
return(new CommandExecutor(input, command, argList));
}
public void TestMzML_MS2()
{
// Get temp path for writing the test mzML
var tempFilePath = Path.GetTempPath();
var testRawFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Data/small2.RAW");
var parseInput = new ParseInput(testRawFile, null, tempFilePath, OutputFormat.MzML);
RawFileParser.Parse(parseInput);
// Deserialize the mzML file
var xmlSerializer = new XmlSerializer(typeof(mzMLType));
var testMzMl = (mzMLType)xmlSerializer.Deserialize(new FileStream(
Path.Combine(tempFilePath, "small2.mzML"), FileMode.Open, FileAccess.Read, FileShare.ReadWrite));
Assert.AreEqual(95, testMzMl.run.spectrumList.spectrum.Length);
var precursor = testMzMl.run.spectrumList.spectrum[16].precursorList.precursor[0].selectedIonList.selectedIon[0];
var selectedMz = Double.Parse(precursor.cvParam.Where(cv => cv.accession == "MS:1000744").First().value);
Assert.IsTrue(selectedMz - 604.7592 < 0.001);
var selectedZ = int.Parse(precursor.cvParam.Where(cv => cv.accession == "MS:1000041").First().value);
Assert.AreEqual(selectedZ, 2);
//var selectedI = Double.Parse(precursor.cvParam.Where(cv => cv.accession == "MS:1000042").First().value);
//Assert.IsTrue(selectedI - 10073 < 1);
Assert.AreEqual(95, testMzMl.run.chromatogramList.chromatogram[0].defaultArrayLength);
}
internal CommandExecutor(ParseInput input, Command command, IEnumerable <CommandArgument> arguments,
string aliasedDescription = null, IEnumerable <string> aliases = null)
{
_arguments = new ReadOnlyCollection <CommandArgument>(arguments.ToList());
if (_arguments.Count != command.Parameters.Count)
{
throw new ArgumentException("Mismatched argument count");
}
_facets = new Lazy <IFacet[]>(InitFacets);
Input = input;
Command = command;
CanInvoke = !ParametersAndArguments.Any(x => !x.Item1.Optional && !x.Item2.IsSpecified);
if (aliasedDescription != null)
{
_aliasedDescription = aliasedDescription;
Description = string.Format("{0} (aliased form of {1})", aliasedDescription, Command.Name);
}
else
{
Description = Command.Name;
}
if (aliases != null)
{
_aliases = new ReadOnlyCollection <string>(aliases.ToArray());
}
GC.SuppressFinalize(this);
}
static ParseResult CreateTextFacetResult(ParseInput input, ParseRange range)
{
var textForRange = input.GetTextForRange(range).Trim();
var moniker = new FacetMoniker(typeof(EngineFacetsFactory), typeof(TextFacet), textForRange, textForRange);
return(new ParseResult(input, range, moniker, ParseResult.ExactMatchRelevance));
}
public void TestFolderMgfs()
{
// Get temp path for writing the test MGF
var tempFilePath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(tempFilePath);
var testRawFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Data/TestFolderMgfs");
var parseInput = new ParseInput(null, testRawFolder, tempFilePath, OutputFormat.MGF);
RawFileParser.Parse(parseInput);
var numFiles = Directory.GetFiles(tempFilePath, "*.mgf");
Assert.AreEqual(numFiles.Length, 2);
var mgfData = Mgf.LoadAllStaticData(Path.Combine(tempFilePath, "small1.mgf"));
Assert.AreEqual(34, mgfData.NumSpectra);
var mgfData2 = Mgf.LoadAllStaticData(Path.Combine(tempFilePath, "small2.mgf"));
Assert.AreEqual(34, mgfData2.NumSpectra);
Directory.Delete(tempFilePath, true);
}
public static void Main(string[] args)
{
var input = ParseInput.ToArray("../../input", ',').ToInts();
input[1] = 12;
input[2] = 2;
// input = ParseInput.ToArray("1,9,10,3,2,3,11,0,99,30,40,50", ',').ToInts(); // sample 1
// input = ParseInput.ToArray("1,0,0,0,99", ',').ToInts(); // sample 2
// input = ParseInput.ToArray("2,3,0,3,99", ',').ToInts(); // sample 3
// input = ParseInput.ToArray("2,4,4,5,99,0", ',').ToInts(); // sample 4
// input = ParseInput.ToArray("1,1,1,4,99,5,6,0,99", ',').ToInts(); // sample 5
var program = new OpProgram(input);
for (int i = 0; i < 100; i++)
{
for (int j = 0; j < 100; j++)
{
input[1] = i;
input[2] = j;
var result = program.Run(input);
if (result == 19690720)
{
goto Finish;
}
}
}
Finish:
Console.WriteLine(100 * input[1] + input[2]);
}
/// <summary>
/// Generate the code from action string
/// </summary>
/// <param name="actionString">Action string</param>
/// <returns></returns>
public static string GenerateActionCode(string actionString)
{
Parameters.ParameterList = ParseInput.Parse(actionString); //Update the parameters
Commands.LoadParametersForCommand("action"); //Update the parameters
ConvertVariablesToJavaScript();
var typeID = -1;
var valueID = -1;
switch (Parameters.Type)
{
case "message":
typeID = 0;
if (Parameters.Channel == "message")
{
valueID = 0; //Channel by message
}
if (Parameters.Channel == "default")
{
valueID = 1; //Channel by default channel
}
if (Parameters.Channel.Replace(" ", "").StartsWith("#"))
{
valueID = 2; //Channel by name
}
if (valueID == -1)
{
valueID = 3; //Channel by ID
}
break;
}
return(GetActionCodeString(typeID, valueID, GetGuildAndChannelCodes(Parameters.Guild, Parameters.Channel),
Parameters.Value));
}
protected override IEnumerable <ParseResult> ParseImpl(ParseInput input, IEnumerable <FacetMoniker> indexEntries)
{
var increment = 1.0 / input.Terms.Count;
foreach (var entry in indexEntries)
{
var relevance = 0.0;
var lower = entry.DisplayName.ToLower();
var range = new ParseRange(0, 0);
foreach (var term in input.Terms)
{
if (lower.StartsWith(term.TextLower))
{
relevance += increment * 1.5;
}
else if (lower.Contains(term.TextLower))
{
relevance += increment;
}
else
{
// require constant progress
break;
}
range = range.Union(term.Range);
if (relevance > 0.0)
{
yield return(new ParseResult(input, range, entry, Math.Min(1.0, relevance)));
}
}
}
}
public DiagramGenerator()
{
InitializeComponent();
g = pan_Diagram.CreateGraphics();//now the graphics object are tied to the panel
draws = new DrawDiagram(g);
controller = new ParseInput();
ClearUI();
EnableSettings();
}
internal CommandExecutor(ParseInput input, Command command, IEnumerable <ParseResult> arguments)
: this(input, command, from a in arguments select new CommandArgument(a))
{
// OK that this check comes after chained constructor
if (input == null)
{
throw new ArgumentNullException("input");
}
}
protected override IEnumerable <ParseResult> ParseImpl(ParseInput input, ParseMode mode, IList <Type> facetTypes)
{
var regex = new Regex(@"[\w\.]+\@\w+(\.\w+)+");
return((from m in regex.Matches(input.Text).Cast <Match>()
let range = new ParseRange(m.Index, m.Length)
let moniker = new FacetMoniker(GetType(), typeof(EmailAddressFacet), m.Value, m.Value, null)
select new ParseResult(input, range, moniker, ParseResult.ExactMatchRelevance)).ToArray());
}
protected override IEnumerable <ParseResult> ParseImpl(ParseInput input, ParseMode mode, IList <Type> facetTypes)
{
Uri uri;
return(from term in input
where term.Text.Contains("://")
where Uri.TryCreate(term.Text, UriKind.Absolute, out uri)
select new ParseResult(term, CreateMonikerOf <UrlFacet>(term.Text, term.Text), 1.0));
}
protected override IEnumerable <ParseResult> ParseImpl(ParseInput input, IEnumerable <FacetMoniker> indexEntries)
{
return(from entry in indexEntries
let fdparts = new[] { entry.DisplayName, entry.FactoryData }
from term in input.Terms
where term.Text.Length > 2
let startsWith = fdparts.Any(x => x.StartsWith(term.Text, StringComparison.OrdinalIgnoreCase))
let contains = startsWith == false && fdparts.Any(x => x.IndexOf(term.Text, StringComparison.OrdinalIgnoreCase) != -1)
where startsWith || contains
select new ParseResult(term, entry, startsWith ? 0.75 : 0.5));
}
protected override IEnumerable <ParseResult> ParseImpl(ParseInput input, ParseMode mode, IList <Type> facetTypes)
{
return(from term in input.Terms
from match in s_regex.Matches(term.Text).Cast <Match>()
where match.Success
let hg = match.Groups["hours"]
let mg = match.Groups["mins"]
let ts = new TimeSpan(hg.Success ? ParseSegment(hg.Value) : 0, mg.Success ? ParseSegment(mg.Value) : 0, 0)
let moniker = CreateMonikerOf <DurationFacet>(ts.ToString(), ts.ToString())
select new ParseResult(term, moniker, 1.0));
}
public static ParseInput RewriteInput(this ParseInput input, LoaderFacetFactory forFactory, bool fromHistory)
{
if (!input.Any(x => x.Mode != TermParseMode.Normal))
{
return(input);
}
return(new ParseInput(input.Where(x =>
(x.Mode == TermParseMode.Normal ||
(x.Mode == TermParseMode.History && fromHistory)) &&
x.IsFactorySourceValid(forFactory))));
}
/// <summary>
/// Generate code for trigger
/// </summary>
/// <param name="commandString"></param>
/// <returns></returns>
public static string GenerateTriggerCode(string commandString)
{
Parameters.ParameterList = ParseInput.Parse(commandString); //Update parameters
switch (Parameters.Type)
{
case "message":
return(CodeGenerator.GenerateOnMessageCode());
}
return(null);
}
static List <List <ParseRange> > CreateRangeLists(ParseInput input, IEnumerable <ParseRange> groups)
{
var resultLists = groups
.Where(x => x.StartIndex == 0)
.Select(result => new List <ParseRange> {
result
})
.ToList();
var resultListsComplete = new List <List <ParseRange> >();
while (resultLists.Count > 0)
{
var resultListsNew = new List <List <ParseRange> >();
foreach (var list in resultLists)
{
// find ParseResults that start immediately to the right of the rightmost ParseResult in 'list'.
// for each of these, make a copy of 'list', add the result to the copy, and add the copy to the
// new set of lists (resultListsNew).
var rightIndex = input.ToCompressed(list[list.Count - 1].EndIndex);
var found = false;
foreach (var result in groups.Where(x => input.ToCompressed(x.StartIndex) == rightIndex + 1))
{
var newList = new List <ParseRange>(list);
newList.Add(result);
resultListsNew.Add(newList);
found = true;
}
if (found)
{
continue;
}
// no further ParseResults can be added to the list
if (rightIndex < input.CompressedText.Length - 1)
{
list.Add(RemainingTextRangeMarker);
}
// the argument list is complete
resultListsComplete.Add(list);
}
resultLists = resultListsNew;
}
return(resultListsComplete);
}
public static void Main(string[] args)
{
var input = ParseInput.ToJaggedArray("../../input", ',');
var wire1 = input[0];
var wire2 = input[1];
// wire1 = "R8,U5,L5,D3".Split(',');
// wire2 = "U7,R6,D4,L4".Split(',');
// wire1 = "R75,D30,R83,U83,L12,D49,R71,U7,L72".Split(',');
// wire2 = "U62,R66,U55,R34,D71,R55,D58,R83".Split(',');
// wire1 = "R7,D3,R8,U8,L1,D4,R7,U7,L7".Split(',');
// wire2 = "U6,R6,U5,R3,D7,R5,D5,R8".Split(',');
wire1 = "R98,U47,R26,D63,R33,U87,L62,D20,R33,U53,R51".Split(',');
wire2 = "U98,R91,D20,R16,D67,R40,U7,R15,U6,R7".Split(',');
var cs1 = LayWire(wire1);
var cs2 = LayWire(wire2);
// File.Write2D("map", Map, 2);
// Console.WriteLine(ClosestCross(500));
// var cs1 = new DiscreteCoordinateSystem();
// cs1.AddPoint(new Point(50, 50));
// cs1.AddPoint(new Point(10, 10));
// var cs2 = new DiscreteCoordinateSystem();
// cs2.AddPoint(new Point(10, 10));
// cs2.AddPoint(new Point(30, 30));
/*var pic1 = Canvas.CreateImage(cs1.GetPoints2D(), "red", new []{0,0});
* var a = cs1.Center - cs2.Center;
* var pic2 = Canvas.CreateImage(cs2.GetPoints2D(), "green", new []{a.x,a.y});
* File.Write2D("pic1.txt", cs1.GetPoints2D(), 2);
* File.Write2D("pic2.txt", cs2.GetPoints2D(), 2);
*
* pic1.Save("pic1.png", ImageFormat.Png);
* pic2.Save("pic2.png", ImageFormat.Png);
*
* var result = Canvas.MultiplyImages(pic1, pic2);
* result.Save("image.png", ImageFormat.Png);
*
*
* var overlapping = cs1.OverlappingPoints(cs2);
* var closest = int.MaxValue;
* foreach (var point in overlapping) {
* if(point == Point.Zero) continue;
* var distance = point.Manhattan;
* if (distance < closest) closest = distance;
* }
*
* Console.WriteLine(closest);
* Console.WriteLine(cs1.Center);
* Console.WriteLine(cs2.Center);*/
}
static CommandExecutor CreateCommand(ParseInput input, CommandExecutor partialExecutor,
List <ParseRange> rangeList, IDictionary <ParseRange, ParseResult[]> groupedResults)
{
var argList = CreateCommand(input, rangeList, groupedResults, partialExecutor.UnspecifiedParameters);
if (argList == null)
{
return(null);
}
return(partialExecutor.CreateSuggestedVersion(input,
partialExecutor.UnspecifiedParameters.Zip(argList, Tuple.Create)));
}
public void TestMgf()
{
// Get temp path for writing the test MGF
var tempFilePath = Path.GetTempPath();
var testRawFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Data/small.RAW");
var parseInput = new ParseInput(testRawFile, null, tempFilePath, OutputFormat.MGF);
RawFileParser.Parse(parseInput);
var mgfData = Mgf.LoadAllStaticData(Path.Combine(tempFilePath, "small.mgf"));
Assert.AreEqual(34, mgfData.NumSpectra);
}
public void CorrectZeroInput()
{
//arrange
string input = "0";
bool expected = true;
//act
var parseInput = new ParseInput();
parseInput.Start(input);
//assert
Assert.AreEqual(expected, parseInput.IsValid);
}
public void OverflowInput()
{
//arrange
string input = "12345678945613456";
bool expected = false;
//act
var parseInput = new ParseInput();
parseInput.Start(input);
//assert
Assert.AreEqual(expected, parseInput.IsValid);
}
public void NullReferenceInput()
{
//arrange
string input = null;
bool expected = false;
//act
var parseInput = new ParseInput();
parseInput.Start(input);
//assert
Assert.AreEqual(expected, parseInput.IsValid);
}
public void NegativeInput()
{
//arrange
string input = "-1";
bool expected = false;
//act
var parseInput = new ParseInput();
parseInput.Start(input);
//assert
Assert.AreEqual(expected, parseInput.IsValid);
}
