/// <summary>
/// Creates a property analyzer.
/// </summary>
/// <param name="analyzer">Sets the analyzer for indexing and searching.</param>
public PropertyAnalyzer(IAnalyzer analyzer)
{
if (analyzer == null)
throw new ArgumentNullException("analyzer", "PropertyAnalyzer expects an analyzer in this constructor.");
Analyzer = analyzer;
}
public void Test(BlackBoxTest integrationTest)
{
var latinParser = new Latin.WordParser();
var word = latinParser.Parse(integrationTest.Latin);
var analyzers = new IAnalyzer[]
{
new MemoizeAnalyzer("classical_latin"),
new Latin.SyllableAnalyzer(),
new Latin.AccentAnalyzer(),
};
foreach (var analyzer in analyzers)
{
analyzer.Analyze(word);
}
var rules = French2.Rules();
var sequencer = new LinearRuleSequencer(rules, new Dictionary <string, IAnalyzer>()
{
{ "syllable", new Latin.SyllableAnalyzer() },
});
var derived = sequencer.Derive(ExecutionContext, word).Select(d => d.Derived).ToArray();
var expected = integrationTest.Outputs;
Assert.Equal(expected.Length, derived.Length);
for (int i = 0; i < expected.Length; i++)
{
TestBlackBoxSample(expected, derived, i);
}
}
public CertificateValidationDiagnosticSuite()
{
Analyzers = new IAnalyzer[]
{
Container.Resolve <CertificateValidationAnalyzer>()
}.ToImmutableArray();
}
private static void Setup(string[] args)
{
_help = args.Any(x => (x == "/help") || (x == "/h"));
_install = args.Any(x => x == "/install");
_waitKeyPressed = args.Any(x => (x == "/i") || (x == "/interactive"));
_processor = new MSBuildLogProcessor();
_analyzer = new SimpleAnalyzer();
if (args.Contains("/csv"))
{
SetupCSVReporter(args);
}
else if (args.Contains("/tc"))
{
_reporter = new TeamCityReporter();
}
else
{
_reporter = new SimpleReporter();
}
_logFile = args.FirstOrDefault(File.Exists);
if (args.Length == 0)
{
_help = _waitKeyPressed = true;
}
}
/// <summary>
/// Reads and reflects the given VB Classic text file into a usable form.
/// </summary>
/// <param name="partitionedFile">An instance of <see cref="VbPartitionedFile"/> representing the VB Classic module to reflect.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"><paramref name="partitionedFile"/> was null.</exception>
/// <exception cref="InvalidOperationException">There was no analyzer considered fitting for the underlying file.</exception>
public static IVbModule GetReflectedModule(VbPartitionedFile partitionedFile)
{
if (partitionedFile == null)
{
throw new ArgumentNullException("partitionedFile");
}
if (Tokenizer == null)
{
throw new InvalidOperationException("No tokenizer defined for analyzing the file!");
}
IReadOnlyList <IToken> tokens = Tokenizer.GetTokens(partitionedFile.GetMergedContent());
TokenStreamReader reader = new TokenStreamReader(tokens);
IAnalyzer analyzer = null;
if (!AnalyzerFactory.TryGetAnalyzerForFile(reader, out analyzer))
{
// TODO: Dedicated exception for this.
throw new InvalidOperationException("Could not analyze the given file!");
}
reader.Rewind();
return(analyzer.Analyze(reader));
}
static void Main(string[] args)
{
userId = args[0];
password = args[1];
aimeId = int.Parse(args[2]);
if (UPDATE_HISTORY)
{
GetMusicDataTable();
UpdateHistory();
}
else
{
var historyCsvPath = "./playlog/history.csv";
if (File.Exists(historyCsvPath))
{
history = ReadHistory(historyCsvPath);
}
var analyzers = new IAnalyzer[]
{
new DeductionAnalyzer(history),
new Analyzer1(history),
};
foreach (var analyzer in analyzers)
{
analyzer.Analyze();
analyzer.Dump();
}
Console.WriteLine("解析完了");
}
Console.ReadLine();
}
public AnalyzerPresenter(IAnalyzerView view, IMessageService service, IAnalyzer analyzer)
{
this.view = view;
this.service = service;
this.analyzer = analyzer;
view.ApplyAnalyzeClick += View_ApplyAnalyzeClick;
}
protected StreamUpsertOperation(string directory, IAnalyzer analyzer, Stream stream, Compression compression, string primaryKey)
: base(directory, analyzer, compression, primaryKey)
{
var bs = new BufferedStream(stream);
Reader = new StreamReader(bs, Encoding.UTF8);
}
public CliLineDocUpsertOperation(string directory, IAnalyzer analyzer, Stream file, int skip, int take, Compression compression, string primaryKey)
: base(directory, analyzer, file, compression, primaryKey)
{
_take = take;
_skip = skip;
_cursorPos = Console.CursorLeft;
}
private void MetaMenuItem_Click(object sender, RoutedEventArgs e)
{
System.Windows.Controls.MenuItem tv = sender as System.Windows.Controls.MenuItem;
FileViewModel fileTopic = tv.DataContext as FileViewModel;
var results = new Dictionary <string, object>();
if (fileTopic.LogFile != null)
{
string tmpStr = string.Empty;
{
foreach (Type analyzerType in PluginFactory.FindAnalyzers(fileTopic.LogFile.GetType()))
{
IAnalyzer analyzer = PluginFactory.CreateAnalyzer(analyzerType);
foreach (var result in analyzer.Analyze(fileTopic.LogFile))
{
results.Add(result.Key, result.Value);
}
}
}
foreach (var item in results)
{
tmpStr += item.Key + ": " + item.Value.ToString() + Environment.NewLine;
}
MessageBox.Show(tmpStr, Properties.Resources.computedDataCaption);
}
}
public void ProcessFile(string fileName, IAnalyzer analyzer)
{
var sw = Stopwatch.StartNew();
StreamReader reader;
if (!TryOpenFile(fileName, out reader))
return;
using(reader)
{
PrintFileInfo(fileName, reader);
ProgressNotifier progressNotifier = ProgressNotifier.Start("Reading and analyzing..", reader.BaseStream.Length - reader.BaseStream.Position);
var chars = new char[4 * 1024];
int read;
while((read = reader.Read(chars, 0, chars.Length)) > 0)
{
for(int i = 0; i < read; i++)
{
analyzer.TreatChar(chars[i]);
}
progressNotifier.ReportCompleted(reader.BaseStream.Position);
}
progressNotifier.Finish();
}
var analysisResult = analyzer.Finish();
Console.Out.WriteLine("----");
Console.Out.WriteLine(analysisResult.ToHumanReadableText());
Console.Out.WriteLine("----");
Console.Out.WriteLine("Working time: " + sw.Elapsed);
}
public void Setup()
{
this.productDataInterpreter = new Mock <IInterpreter <int> >(MockBehavior.Strict);
this.queryInterpreter = new Mock <IInterpreter <string> >(MockBehavior.Strict);
this.analyzer = new Analyzer(this.productDataInterpreter.Object, this.queryInterpreter.Object);
}
public StaticAnalyzer(IStaticProvider provider, IAnalyzer embeddedAnalyzer, IDictionary <int, ISolverSubdomain> subdomains)
{
this.provider = provider;
this.childAnalyzer = embeddedAnalyzer;
this.subdomains = subdomains;
this.childAnalyzer.ParentAnalyzer = this;
}
public async Task <IActionResult> QueueAnalyzes(
Guid mrRecordId,
[FromBody] QueueAnalyzesRequest request,
[FromServices] IAnalyzer analyzer)
{
var targetRecord = await dbContext.MrRecords.SingleOrDefaultAsync(r => r.Id == mrRecordId);
if (targetRecord == null)
{
return(NotFound());
}
var algs = await dbContext.MrAlgorithms.Where(a => request.Algorithms.Contains(a.Id)).ToListAsync();
if (algs.Count != request.Algorithms.Count)
{
return(NotFound());
}
var analyzes = algs.Select(a => new MrAnalyze
{
MrAlgorithm = a,
MrRecord = targetRecord,
Status = MrAnalyzeStatus.InQueue
}).ToList();
dbContext.AddRange(analyzes);
await dbContext.SaveChangesAsync();
await Task.WhenAll(analyzes.Select(a => analyzer.Analyze(a)));
return(Ok());
}
public Processor(
IPreProcessor preProcessor,
IAnalyzer analyzer)
{
this.preProcessor = preProcessor;
this.analyzer = analyzer;
}
public static IEnumerable <Invocation> GetInvocations(this IAnalyzer extractor, string text, string fileName = null)
{
using (var reader = new StringReader(text))
{
return(extractor.GetInvocations(reader, fileName: fileName));
}
}
internal InputAnalyzer(ObservableDictionary <string, string> parameters, IDevice device, IAnalyzer analyzer)
{
_parameters = parameters;
_analyzer = analyzer;
_analyzerWrapper = new AnalyzerWrapper(analyzer, parameters);
_analyzerWrapper.Run();
_device = device;
_input = device.GamingInput;
if (_input is ISkeletonInput && analyzer is ISkeletonAnalyzer)
{
(_input as ISkeletonInput).SkeletonChanged +=
(_skeleton_handler = new EventHandler <SkeletonChangedEventArgs>(InputAnalyzer_SkeletonChanged));
}
else if (_input is IAccelerometerInput && analyzer is IAccelerometerAnalyzer)
{
(_input as IAccelerometerInput).AccelerometerChanged +=
(_accelerometer_handler = new EventHandler <AccelerometerChangedEventArgs>(InputAnalyzer_AccelerometerChanged));
}
else if (_input is IBalanceBoardInput && analyzer is IBalanceBoardAnalyzer)
{
(_input as IBalanceBoardInput).BalanceChanged +=
(_ballanceBoard_handler = new EventHandler <BalanceChangedEventArgs>(InputAnalyzer_BalanceChanged));
}
else if (_input is IEmgSensorInput && analyzer is IEmgSignalAnalyzer)
{
(_input as IEmgSensorInput).MuscleActivationChanged +=
(_emg_handler = new EventHandler <MuscleActivationChangedEventArgs>(InputAnalyzer_MuscleActivationChanged));
}
}
public PolynomialChaosAnalyzer(Model model, IAnalyzerProvider provider, IAnalyzer embeddedAnalyzer, IDictionary <int, ISolverSubdomain> subdomains, IPCCoefficientsProvider coefficientsProvider, int expansionOrder, int simulations, bool shouldFactorizeMatrices)
{
this.shouldFactorizeMatrices = shouldFactorizeMatrices;
this.childAnalyzer = embeddedAnalyzer;
this.provider = provider;
this.model = model;
this.subdomains = subdomains;
this.expansionOrder = coefficientsProvider.ExpansionOrder;
this.simulations = simulations;
this.childAnalyzer.ParentAnalyzer = this;
this.matrices = new Dictionary <int, IMatrix2D <double> > [coefficientsProvider.NoOfMatrices + 1];
this.randomNumbers = new double[simulations][];
this.coefficientsProvider = coefficientsProvider;
NormalDistribution n = new NormalDistribution();
n.Mu = 0;
n.Sigma = 1;
string[] randoms = new string[simulations];
for (int i = 0; i < simulations; i++)
{
randomNumbers[i] = new double[expansionOrder];
for (int j = 0; j < expansionOrder; j++)
{
randomNumbers[i][j] = n.NextDouble();
}
randoms[i] = randomNumbers[i][0].ToString();
}
//File.WriteAllLines(String.Format(@"randoms.txt", expansionOrder), randoms);
}
public IndexWriter(string directory, IAnalyzer analyzer)
{
_directory = directory;
_analyzer = analyzer;
_docFile = new DocumentFile(directory);
_fieldFiles = new Dictionary <int, FieldFile>();
_fieldIndexFileName = Path.Combine(_directory, "fld.ix");
if (File.Exists(_fieldIndexFileName))
{
using (var fs = File.OpenRead(_fieldIndexFileName))
{
_fieldIndex = Serializer.Deserialize <Dictionary <string, int> >(fs);
}
}
else
{
_fieldIndex = new Dictionary <string, int>();
}
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
}
public FullTextIndex(StorageEnvironmentOptions options, IAnalyzer analyzer)
{
Analyzer = analyzer;
Conventions = new IndexingConventions();
BufferPool = new BufferPool();
StorageEnvironment = new StorageEnvironment(options);
using (var tx = StorageEnvironment.NewTransaction(TransactionFlags.ReadWrite))
{
StorageEnvironment.CreateTree(tx, "@terms", keysPrefixing: true);
StorageEnvironment.CreateTree(tx, "deletes", keysPrefixing: true);
var docs = StorageEnvironment.CreateTree(tx, "docs", keysPrefixing: true);
var metadata = StorageEnvironment.CreateTree(tx, "$metadata");
var idVal = metadata.Read("id");
if (idVal == null)
{
Id = Guid.NewGuid();
metadata.Add("id", Id.ToByteArray());
}
else
{
int _;
Id = new Guid(idVal.Reader.ReadBytes(16, out _));
}
using (var it = docs.Iterate())
{
_lastDocumentId = it.Seek(Slice.AfterAllKeys) == false ?
0 :
it.CurrentKey.CreateReader().ReadBigEndianInt64();
}
tx.Commit();
}
}
//public MonteCarloAnalyzer(Model model, IAnalyzerProvider provider, IAnalyzer embeddedAnalyzer, IDictionary<int, ISolverSubdomain> subdomains, double[] stochasticDomain, int expansionOrder, int simulations)
public MonteCarloAnalyzer(Model model, IAnalyzerProvider provider, IAnalyzer embeddedAnalyzer, IDictionary <int, ISolverSubdomain> subdomains, GaussianFileStochasticCoefficientsProvider coefficientsProvider, int expansionOrder, int simulations)
{
this.childAnalyzer = embeddedAnalyzer;
this.provider = provider;
this.model = model;
this.subdomains = subdomains;
this.expansionOrder = expansionOrder;
this.simulations = simulations;
this.childAnalyzer.ParentAnalyzer = this;
//this.matrices = new Dictionary<int, IMatrix2D<double>>(subdomains.Count);
this.matrices = new Dictionary <int, IMatrix2D <double> > [expansionOrder + 1];
this.randomNumbers = new double[simulations][];
this.coefficientsProvider = coefficientsProvider;
//this.stochasticDomain = stochasticDomain;
NormalDistribution n = new NormalDistribution();
n.Mu = 0;
n.Sigma = 1;
string[] randoms = new string[simulations];
for (int i = 0; i < simulations; i++)
{
randomNumbers[i] = new double[expansionOrder];
for (int j = 0; j < expansionOrder; j++)
{
randomNumbers[i][j] = n.NextDouble();
}
randoms[i] = randomNumbers[i][0].ToString();
}
File.WriteAllLines(String.Format(@"randoms.txt", expansionOrder), randoms);
}
public Indexer(FullTextIndex parent)
{
_parent = parent;
_analyzer = _parent.Analyzer;
_bufferPool = _parent.BufferPool;
AutoFlush = true;
}
public AnalysisBasedConstraint(IAnalyzer <IMetric> analyzer,
Func <V, bool> assertion, Option <string> hint)
{
Analyzer = analyzer;
_assertion = assertion;
_hint = hint;
}
public Indexer(FullTextIndex parent)
{
_parent = parent;
_analyzer = _parent.Analyzer;
_bufferPool = _parent.BufferPool;
AutoFlush = true;
}
public void Init()
{
base.Init();
this.analyzer = ServiceProvider.GetService <IAnalyzer>();
this.mediator = ServiceProvider.GetService <IMediator>();
}
public Parser(Uri uri, int depth, int maxCount, HttpClient client, IAnalyzer analyzer)
{
#region Проверки
if (uri is null)
{
throw new ArgumentNullException("uri is null");
}
if (depth <= 1)
{
throw new ArgumentOutOfRangeException("depth must be greater than 1");
}
if (maxCount <= 1)
{
throw new ArgumentOutOfRangeException("maxCount must be greater than 1");
}
if (client is null)
{
throw new ArgumentNullException("client is null");
}
if (analyzer is null)
{
throw new ArgumentNullException("analyzer is null");
}
#endregion
URI = uri;
Depth = depth;
MaxCount = maxCount;
Client = client;
Analyzer = analyzer;
Analyzer.Finded += s => Finded.Invoke(s);
}
public AnalyzerSearchTreeNode(ISymbol symbol, IAnalyzer analyzer, string analyzerHeader)
{
this.symbol = symbol;
this.analyzer = analyzer ?? throw new ArgumentNullException(nameof(analyzer));
this.LazyLoading = true;
this.analyzerHeader = analyzerHeader;
}
public void AddAnalyzer <T>()
where T : IAnalyzer
{
if (RootAnalyzer == null)
{
RootAnalyzer = Activator.CreateInstance <T>();
return;
}
var analyzer = RootAnalyzer;
var nextAnalyzer = RootAnalyzer.NextAnalyzer;
while (true)
{
if (nextAnalyzer == null)
{
var instanse = Activator.CreateInstance <T>();
analyzer.NextAnalyzer = instanse;
break;
}
else
{
analyzer = nextAnalyzer;
nextAnalyzer = analyzer.NextAnalyzer;
}
}
}
protected AbstractUseNamedArgumentsCodeRefactoringProvider(
IAnalyzer argumentAnalyzer,
IAnalyzer attributeArgumentAnalyzer)
{
_argumentAnalyzer = argumentAnalyzer;
_attributeArgumentAnalyzer = attributeArgumentAnalyzer;
}
public IAnalyzer Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
try
{
IAnalyzer result = null;
var highestHand = CardHelper.FindBestHand(string.Join("", playerCards.Select(c => c.CardStringValue)), boardCards.ToString());
var analyzers = ReferenceEquals(highestHand, null) ? _combinations : _combinations.Where(x => x.IsValidAnalyzer(highestHand)).ToArray();
if (playerCards.Count() > 2 && !string.IsNullOrEmpty(highestHand.PocketCards))
{
result = analyzers.FirstOrDefault(combination => combination.Analyze(CardGroup.Parse(highestHand.PocketCards), boardCards)) ?? new StubAnalyzer();
}
else
{
result = analyzers.FirstOrDefault(combination => combination.Analyze(playerCards, boardCards)) ?? new StubAnalyzer();
}
return(result);
}
catch (Exception ex)
{
LogProvider.Log.Error(this, String.Format("Hand Analyzer Error occurred: Player cards = {0}; Board Cards = {1}", string.Join("", playerCards.Select(c => c.CardStringValue)), boardCards.ToString()), ex);
}
return(new StubAnalyzer());
}
public CliLineDocUpsertOperation(string directory, IAnalyzer analyzer, int skip, int take, Compression compression, string primaryKey, Stream documents)
: base(directory, analyzer, compression, primaryKey, documents)
{
_take = take;
_skip = skip;
_autoGeneratePk = string.IsNullOrWhiteSpace(primaryKey);
}
public Processor()
{
var ninjectKernel = new StandardKernel(new SimpleConfigModule());
_extension = ninjectKernel.Get <IExtension>();
_analyzer = ninjectKernel.Get <IAnalyzer>();
}
public static void Main(string[] args)
{
var env = Environment.GetEnvironmentVariable("TWITTER_ENV") ?? "Development";
var cwd = Directory.GetCurrentDirectory();
var builder = new ConfigurationBuilder()
.SetBasePath(cwd)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env}.json", optional: true)
.AddEnvironmentVariables();
var configuration = builder.Build();
var serviceCollection = new ServiceCollection();
serviceCollection.AddLanguage(configuration.GetSection("Language"));
serviceCollection.AddTwitter(configuration.GetSection("Twitter"));
serviceCollection.AddMeDaUmFilme();
var services = serviceCollection.BuildServiceProvider();
languageAnalyzer = services.GetService <IAnalyzer>();
meDaUmFilmeSearch = services.GetService <IMeDaUmFilmeSearch>();
var twitter = services.GetService <Twitter.Twitter>();
twitter.ListenAsync("@medaumfilme", Listen);
Console.WriteLine("Waiting...");
Console.ReadLine();
}
public void runFull(IAnalyzer analyzer, DataItem item, AssetTimeframe atf)
{
this.atf = atf;
if (item == null) return;
if (item.Quotation == null) return;
runLeftSide(analyzer, item, atf);
}
/// <summary>
/// Create a property analyzer that uses different analysis for indexing and searching.
/// </summary>
/// <param name="indexAnalyzer">Sets the analyzer to use for indexing a property.</param>
/// <param name="searchAnalyzer">Sets the analyzer to use for searching a property. Optional.</param>
public PropertyAnalyzer(IAnalyzer indexAnalyzer, IAnalyzer searchAnalyzer)
{
if (indexAnalyzer == null)
throw new ArgumentNullException("indexAnalyzer", "PropertyAnalyzer expects an indexAnalyzer in this constructor.");
IndexAnalyzer = indexAnalyzer;
if (searchAnalyzer != null)
SearchAnalyzer = searchAnalyzer;
}
static QueryObjectParser()
{
Analyzers = new IAnalyzer[]
{
new EqualAnalyzer(),
new ListContainsAnalyzer(),
new RangeAnalyzer(),
new StringContainsAnalyzer(),
new NavigationAnalyzer(),
};
}
private static IAnalyzer factory(IAnalyzer analyzer, List<float> data_float)
{
switch (analyzer.Name)
{
case Averager.Type_Name:
return new Averager(data_float, analyzer);
//break;
default: // found no known type for that name
return analyzer;
}
}
internal static bool TryGetAnalyzerForFile(TokenStreamReader reader, out IAnalyzer analyzer)
{
var best = _analyzers.FirstOrDefault(_ => _.CanAnalyze(reader.Rewind()));
if (best != null)
{
analyzer = best;
return true;
}
analyzer = null;
return false;
}
public void runRightSide(IAnalyzer analyzer, DataItem item, AssetTimeframe atf)
{
this.atf = atf;
if (item == null) return;
if (item.Quotation == null) return;
//Calculate new values for peaks and troughs and apply them to the current item price.
//If any of this is changed, this price will have flag [IsChange] set to @true.
//This is the only thing that can be changed for items being only updated.
CheckForExtremum(item, ExtremumType.PeakByClose, false);
CheckForExtremum(item, ExtremumType.PeakByHigh, false);
CheckForExtremum(item, ExtremumType.TroughByClose, false);
CheckForExtremum(item, ExtremumType.TroughByLow, false);
CheckPriceGap(item);
}
public FullTextIndex(StorageEnvironmentOptions options, IAnalyzer analyzer)
{
Analyzer = analyzer;
Conventions = new IndexingConventions();
BufferPool = new BufferPool();
StorageEnvironment = new StorageEnvironment(options);
using (var tx = StorageEnvironment.NewTransaction(TransactionFlags.ReadWrite))
{
ReadMetadata(tx);
ReadLastDocumentId(tx);
ReadFields(tx);
tx.Commit();
}
}
private void AddDocument(Document document, IAnalyzer analyzer)
{
if (document.Key == Guid.Empty)
document.Key = Guid.NewGuid();
DocumentStorage.Add(document);
System.Diagnostics.Debug.Assert(document.Value.CanSeek);
document.Value.Seek(0, SeekOrigin.Begin);
var termPositions = analyzer.GetTermPositions(document.Value);
foreach(var termPositionsGroup in termPositions.GroupBy(a=>a.Term))
{
var term = new Term(
termPositionsGroup.Key,
termPositionsGroup.Select(a => new DocumentLocation { Document = document.Key, Span = a.Span }));
TermStorage.Add(term);
}
}
public void runFull(IAnalyzer analyzer, DataItem item, AssetTimeframe atf)
{
}
public void runFull(IAnalyzer analyzer, int index, AssetTimeframe atf)
{
}
public GenericTranslator(IAnalyzer analyzer)
{
this.analyzer = analyzer;
}
public SingleDocumentIndex(Document document, IAnalyzer analyzer)
: this(document, analyzer, new MemoryStream(), new MemoryStream(), new MemoryStream(), new MemoryStream())
{
}
public SingleDocumentIndex(Document document, IAnalyzer analyzer, Stream termIndexStream, Stream termRecordStorageStream, Stream documentIndexStream, Stream documentRecordStorageStream)
: this(document, analyzer, new TermStorage(termIndexStream, termRecordStorageStream), new DocumentStorage(documentIndexStream, documentRecordStorageStream))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="T:AnalyzerException"/> class.
/// </summary>
public AnalyzerException(IAnalyzer analyzer) {
Analyzer = analyzer;
}
public MetricsWorker(ICloudService cloudService, IAnalyzer analyzer, IPluginFactory pluginFactory)
{
Analyzer = analyzer;
PluginFactory = pluginFactory;
}
public void runRightSide(IAnalyzer analyzer, int index, AssetTimeframe atf)
{
DataItem item = analyzer.getDataItem(index);
runRightSide(analyzer, item, atf);
}
public TextAnalyzer()
{
Analyzer = new ZalAnalyzer();
}
private void runLeftSide(IAnalyzer analyzer, DataItem item, AssetTimeframe atf)
{
//Check if quotation is missing (but only in the middle of not-missing quotations,
//because missing quotations at the end of array was excluded one line above).
//If it is copy data from the previous quotation.
if (!item.Quotation.IsComplete())
{
var previousQuotation = (item.Index > 0 ? analyzer.getDataItem(item.Index - 1).Quotation : null);
if (previousQuotation != null)
{
item.Quotation.CompleteMissing(previousQuotation);
//_dataService.UpdateQuotation(item.Quotation, Symbol);
}
}
//Ensure that [Price] object is appended to this [DataItem].
item.Price = new Price();
item.Price.Date = item.Date;
if (item.Index > 0) item.Price.CloseDelta = CalculateDeltaClosePrice(item.Quotation.Close, item.Index);
item.Price.Direction2D = CalculateDirection2D(item.Index);
item.Price.Direction3D = CalculateDirection3D(item.Index);
//Calculate new values for peaks and troughs and apply them to the current item price.
//If any of this is changed, this price will have flag [IsChange] set to @true.
//This is the only thing that can be changed for items being only updated.
CheckForExtremum(item, ExtremumType.PeakByClose, true);
CheckForExtremum(item, ExtremumType.PeakByHigh, true);
CheckForExtremum(item, ExtremumType.TroughByClose, true);
CheckForExtremum(item, ExtremumType.TroughByLow, true);
CheckPriceGap(item);
}
public Analyzer(IAnalyzer analyyzer_interface_object)
{
Name = analyyzer_interface_object.Name;
Description = analyyzer_interface_object.Description;
_IAanlyzer = analyyzer_interface_object;
}
public SimplifierTest()
{
simplifier = new Simplifier();
}
/// <summary>
/// Initializes a new instance of the <see cref="T:AnalyzerException"/> class with a specified error message and a reference to the inner exception that is the cause of this exception.
/// </summary>
/// <param name="analyzer">The analyzer which the exception occurred.</param>
/// <param name="message">The error message that explains the reason for the exception. </param>
/// <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. </param>
public AnalyzerException(IAnalyzer analyzer, string message, Exception innerException)
: base(message, innerException) {
Analyzer = analyzer;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Exception"/> class with a specified error message.
/// </summary>
/// <param name="analyzer">The analyzer which the exception occurred.</param>
/// <param name="message">The message that describes the error. </param>
public AnalyzerException(IAnalyzer analyzer, string message) : base(message) {
Analyzer = analyzer;
}
public void runRightSide(IAnalyzer analyzer, int index, AssetTimeframe atf)
{
}
public void runRightSide(IAnalyzer analyzer, DataItem item, AssetTimeframe atf)
{
}
public SingleDocumentIndex(Document document, IAnalyzer analyzer, TermStorage termStorage, DocumentStorage documentStorage)
{
TermStorage = termStorage;
DocumentStorage = documentStorage;
AddDocument(document, analyzer);
}
public TextAnalyzer(IAnalyzer _Analyzer)
{
Analyzer = _Analyzer;
}
public Averager(List<float> data, IAnalyzer analyzer)
{
_Data = data;
Name = analyzer.Name;
Description = analyzer.Description;
}
