private double CalcFunct1(TaskParameters taskP)
{
double f = 0;
var val = new List <double>();
var v = new List <Vector>();
double h = res.GetH();
var rk = new Vector[res.Count - 1];
rk[0] = new Vector(1, startP[0]);
itab[0] = 1;
double t = res[0].X;
for (int i = 1; i < res.Count - 1; i++)
{
val.Clear();
v.Clear();
for (int j = 0; j < tw.SetCount; j++)
{
double x1 = rk[i - 1][0] + tw.FunctionSet(t, rk[i - 1], j, taskP) * h;
v.Add(new Vector(1, x1));
val.Add(Math.Abs(x1 - res[i].Y[0]));
}
double min = val.Min();
int index = val.IndexOf(min);
rk[i] = v[index];
itab[i] = index + 1;
f += min * min * h;
t = t + h;
}
return(f);
}
/// <summary>
/// This method is only for paramteter customizing (merge with Schedule(string name, ?)
/// TaskName should be preinitialized and point to existing named tp in container.
/// </summary>
/// <param name="tp"></param>
/// <param name="parallelism"></param>
/// <param name="dueInSeconds"></param>
protected void Schedule(TaskParameters tp,
ScheduleTaskParallelism parallelism = ScheduleTaskParallelism.AllowOthers,
int dueInSeconds = 0)
{
lock (runningTasks)
{
if (!IsStarted)
{
throw new InvalidOperationException("Task scheduler is not running");
}
log.Info("Scheduling " + tp);
var entity = new ScheduleEntity()
{
NextExecution = DateTime.MaxValue,
Parallelism = parallelism,
TaskName = tp.TaskName,
};
lock (repoLocker)
{
repo.Save(entity);
repo.LoadSettingsIfNull(entity);
foreach (KeyValuePair <string, object> setting in tp.Settings)
{
entity.Settings.AddEntry(setting.Key, setting.Value);
}
entity.NextExecution = DateTime.Now.AddSeconds(Math.Max(0, dueInSeconds));
repo.Update(entity);
}
}
}
private LeveledTask addTask(ref ConcurrentDictionary <string, ConcurrentDictionary <string, long> > allresult,
TaskParameters taskP,
string q,
int maxSleep,
bool IsHighPrority = false)
{
var result = allresult;
LeveledTask lt = new LeveledTask((param) =>
{
var p = param as TaskParameters;
var resultQ = result.GetOrAdd(p.Q, new ConcurrentDictionary <string, long>());
resultQ.AddOrUpdate(string.Concat("S", p.Seq), DateTime.UtcNow.Ticks, (key, current) => { throw new InvalidOperationException("Found existing key"); });
//Trace.WriteLine(string.Format("Task {0} on Queue {1} - Start", p.Seq, p.Q), "info");
Thread.Sleep(maxSleep);
//Trace.WriteLine(string.Format("Task {0} on Queue {1} - End", p.Seq, p.Q), "info");
resultQ.AddOrUpdate(string.Concat("E", p.Seq), DateTime.UtcNow.Ticks, (key, current) => { throw new InvalidOperationException("Found existing key"); });
},
taskP);
lt.QueueId = q;
lt.IsHighPriority = IsHighPrority;
lt.Start(scheduler);
return(lt);
}
public void RunCode(string[] firstPlayerCode, string[] secondPlayerCode, string pathToField, GameFinishType finishType, IEnumerable <BLL.Models.Bot> bots1, IEnumerable <BLL.Models.Bot> bots2, int finalX = 0, int finalY = 0)
{
CompilationResult compResult1 = compiler.CompileCode(TaskParameters.Build(firstPlayerCode.Length), firstPlayerCode);
CompilationResult compResult2 = compiler.CompileCode(TaskParameters.Build(secondPlayerCode.Length), secondPlayerCode);
if (!compResult1.IsCodeCorrect || !compResult2.IsCodeCorrect)
{
throw new ArgumentException("Unable to compile code");
}
FieldBuilder fieldBuilder = new FieldBuilder(pathToField);
Runner.CodeRunners.Models.Field field = fieldBuilder.GetFieldForRunner();
field = fieldBuilder.PlaceBots(field, bots1.Select(b => new Models.Bot(b.X, b.Y, b.Name)), 1);
field = fieldBuilder.PlaceBots(field, bots2.Select(b => new Models.Bot(b.X, b.Y, b.Name)), 2);
FinishGameCondition finishCondition = null;
if (finishType == GameFinishType.CommandsNumber)
{
finishCondition = new CommandNumberCondition();
}
else
{
finishCondition = new BotOnPointCondition(finalX, finalY);
}
IEnumerable <Runner.CodeRunners.Models.Bot> runnerBots1 = bots1.Select(mapper.Map <Runner.CodeRunners.Models.Bot>);
IEnumerable <Runner.CodeRunners.Models.Bot> runnerBots2 = bots2.Select(mapper.Map <Runner.CodeRunners.Models.Bot>);
runner.RunCodeGame(compResult1.InformationForCodeRunner, compResult2.InformationForCodeRunner, field, runnerBots1, runnerBots2, finishCondition);
runner.GameFinished += Runner_GameFinished;
}
protected async override Task OnConsume(string example, TaskParameters taskParameters, ClientActiveTasks cleanup)
{
registerTask(cleanup, "ExampleTask"); // may throw AlreadyInProgress exception
_logger.LogInformation("Example Task Starting");
int captionCount = 0;
int transcriptionCount = 0;
using (var _context = CTDbContext.CreateDbContext())
{
CaptionQueries captionQueries = new CaptionQueries(_context);
var transcriptions = await _context.Transcriptions.Take(30).ToListAsync();
foreach (var transcription in transcriptions)
{
var transcriptionId = transcription.Id;
var videoID = transcription.VideoId;
var captions = await captionQueries.GetCaptionsAsync(transcriptionId);
_logger.LogInformation($"{transcription.Id}: Caption count= {captions.Count}");
transcriptionCount++;
}
}
_logger.LogInformation($"Example Task Done. transcriptionCount={transcriptionCount} captionCount={captionCount}");
}
#pragma warning disable 1998
protected async override Task OnConsume(string emptyString, TaskParameters taskParameters, ClientActiveTasks cleanup)
{
// Maybe in the future if we use this task again: registerTask(cleanup, "RefreshAccessTokenAsync"); // may throw AlreadyInProgress exception
// no. xx nope await _box.RefreshAccessTokenAsync();
// refreshing the Box access token caused the token to go stale
// We've had a better experience not refreshing it
}
protected void lnkBreakWithCopy_Click(Object sender, EventArgs e)
{
// Check permission
CheckModifyPermission(true);
// Break permission inheritance and copy parent permissions
AclInfoProvider.BreakInheritance(Node, true);
// Log staging task
TaskParameters taskParam = new TaskParameters();
taskParam.SetParameter("copyPermissions", true);
DocumentSynchronizationHelper.LogDocumentChange(Node, TaskTypeEnum.BreakACLInheritance, Node.TreeProvider, SynchronizationInfoProvider.ENABLED_SERVERS, taskParam, Node.TreeProvider.AllowAsyncActions);
// Insert information about this event to event log.
if (DocumentManager.Tree.LogEvents)
{
EventLogProvider.LogEvent(EventType.INFORMATION, "Content", "DOCPERMISSIONSMODIFIED", ResHelper.GetAPIString("security.documentpermissionsbreakcopy", "Inheritance of the parent page permissions have been broken. Parent page permissions have been copied."), eventUrl, DocumentManager.Tree.UserInfo.UserID, DocumentManager.Tree.UserInfo.UserName, Node.NodeID, DocumentName, ipAddress, Node.NodeSiteID);
}
lblInheritanceInfo.Text = GetString("Security.InheritsInfo.DoesNotInherit");
SwitchBackToPermissionsMode();
// Clear and reload
securityElem.InvalidateAcls();
securityElem.LoadOperators(true);
}
/// <summary>Extracts scene information for a video.
/// Beware: It is possible to start another scene task while the first one is still running</summary>
protected async override Task OnConsume(string videoId, TaskParameters taskParameters, ClientActiveTasks cleanup)
{
registerTask(cleanup, videoId); // may throw AlreadyInProgress exception
using (var _context = CTDbContext.CreateDbContext())
{
Video video = await _context.Videos.FindAsync(videoId);
if (video.SceneData == null || taskParameters.Force)
{
var jsonString = await _rpcClient.PythonServerClient.GetScenesRPCAsync(new CTGrpc.File
{
FilePath = video.Video1.VMPath
});
JArray scenes = JArray.Parse(jsonString.Json);
video.SceneData = new JObject
{
{ "Scenes", scenes }
};
await _context.SaveChangesAsync();
}
}
}
protected async override Task OnConsume(string example, TaskParameters taskParameters, ClientActiveTasks cleanup)
{
registerTask(cleanup, "BuildElasticIndexTask"); // may throw AlreadyInProgress exception
GetLogger().LogInformation("BuildElasticIndexTask Starting");
using (var _context = CTDbContext.CreateDbContext())
{
CaptionQueries captionQueries = new CaptionQueries(_context);
var all_transcriptions = await _context.Transcriptions.Where(t => t.Language == Languages.ENGLISH_AMERICAN).ToListAsync();
foreach (var transcription in all_transcriptions)
{
var all_captions = transcription.Captions;
// each index has the unique name "index_string_unique", the current in use one has the alias "index_string_alias"
var index_string_base = transcription.Id + "_" + Languages.ENGLISH_AMERICAN.ToLower(System.Globalization.CultureInfo.CurrentCulture);
var index_string_unique = index_string_base + "_" + $"{DateTime.Now:yyyyMMddHHmmss}";
var index_string_alias = index_string_base + "_" + "primary";
var asyncBulkIndexResponse = await _client.BulkAsync(b => b
.Index(index_string_unique)
.IndexMany(all_captions)
);
var alias_exist = await _client.Indices.ExistsAsync(index_string_alias);
if (alias_exist.Exists)
{
var oldIndices = await _client.GetIndicesPointingToAliasAsync(index_string_alias);
var oldIndexName = oldIndices.First().ToString();
var indexResponse = await _client.Indices.BulkAliasAsync(new BulkAliasRequest
{
Actions = new List <IAliasAction>
{
new AliasRemoveAction {
Remove = new AliasRemoveOperation {
Index = oldIndexName, Alias = index_string_alias
}
},
new AliasAddAction {
Add = new AliasAddOperation {
Index = index_string_unique, Alias = index_string_alias
}
}
}
});
}
else
{
var putAliasResponse = await _client.Indices.PutAliasAsync(new PutAliasRequest(index_string_unique, index_string_alias));
}
}
}
GetLogger().LogInformation("BuildElasticIndexTask Done");
}
public TaskWorker(TaskParameters p, Type t, string mf, string sf, object target)
{
TaskParams = p;
MainFunctionName = mf;
SecondFunctionName = sf;
classType = t;
this.target = target;
}
public CompilationResultDTO CompileBotsCode(string[] code, int botsCount)
{
this.ConfigureMapper();
CompilationResult res = compiler.CompileCode(TaskParameters.Build(botsCount), code);
return(_mapper.Map <CompilationResultDTO>(res));
}
public void CanParseEnumeration()
{
var p = new TaskParameters(new Dictionary <string, string> {
{ "lake", "constance" }
});
Assert.That(p.Parameter <Lakes>("lake"), Is.EqualTo(Lakes.Constance));
}
public void CanParseDefaultStringParameter()
{
var p = new TaskParameters(new Dictionary <string, string> {
{ "file", "thefile.txt" }
});
Assert.That(p.Parameter("file", "afile.txt"), Is.EqualTo("thefile.txt"));
}
public void CanParseStringParameterWithType()
{
var p = new TaskParameters(new Dictionary <string, string> {
{ "file", "thefile.txt" }
});
Assert.That(p.Parameter(typeof(string), "file", "afile.txt"), Is.EqualTo("thefile.txt"));
}
public void AsyncAsync()
{
var maxQueue = 10;
var maxTasks = 5000;
var maxSleep = 10;
var IsHighPrority = false;
var result = new ConcurrentDictionary <string, ConcurrentDictionary <string, long> >();
var sw = new Stopwatch();
sw.Start();
var Tasks = new List <Task>();
for (var qNum = 1; qNum <= maxQueue; qNum++)
{
var qName = string.Concat("Q", qNum);
for (var Seq = 1; Seq < maxTasks / maxQueue; Seq++)
{
var taskP = new TaskParameters()
{
Q = qName, Seq = Seq
};
LeveledTask lt = new LeveledTask(async(param) =>
{
// this force the new task not to be inlined.
await Task.Factory.StartNew(async() => { await Task.Delay(100); }, TaskCreationOptions.LongRunning);
var p = param as TaskParameters;
var resultQ = result.GetOrAdd(p.Q, new ConcurrentDictionary <string, long>());
resultQ.AddOrUpdate(string.Concat("S", p.Seq), DateTime.UtcNow.Ticks, (key, current) => { throw new InvalidOperationException("Found existing key"); });
//Trace.WriteLine(string.Format("Task {0} on Queue {1} - Start", p.Seq, p.Q), "info");
Thread.Sleep(maxSleep);
//Trace.WriteLine(string.Format("Task {0} on Queue {1} - End", p.Seq, p.Q), "info");
resultQ.AddOrUpdate(string.Concat("E", p.Seq), DateTime.UtcNow.Ticks, (key, current) => { throw new InvalidOperationException("Found existing key"); });
},
taskP);
lt.QueueId = qName;
lt.IsHighPriority = IsHighPrority;
lt.Start(scheduler);
Tasks.Add(lt);
}
}
Task.WhenAll(Tasks).Wait();
sw.Stop();
Trace.WriteLine(string.Format("{0} Tasks on {1} Queues - Executed in {2} sec", maxTasks, maxQueue, sw.Elapsed.Seconds), "info");
//verify(ref result);
// tasks that uses normal start.run will lose order in the queue.
// the only way that tasks maintain order is to by using
// leveled tasks to create sub tasks.
}
public void TestMagicHeaderMissing()
{
const string text = "Test test test, ho ho ho. ";
const string compressedTxt = "compressed.txt";
File.WriteAllText("in.txt", text);
var parameters = new TaskParameters(ProcessorMode.Decompress, "in.txt", compressedTxt);
var processor = new TaskProcessor(new LoggerMock());
Assert.Throws<Exception>(() => processor.Start(parameters).Wait());
}
public Vector AbstractFunction(double t, Vector y, TaskParameters tps)
{
object res = classType.InvokeMember(MainFunctionName, BindingFlags.Public
| BindingFlags.InvokeMethod
| BindingFlags.Instance | BindingFlags.Static, null,
target,
new object[] {t, y, tps});
return res as Vector;
}
public double FunctionSet(double t, Vector y, int index, TaskParameters tp)
{
object res = classType.InvokeMember(SecondFunctionName, BindingFlags.Public
| BindingFlags.InvokeMethod
| BindingFlags.Instance | BindingFlags.Static, null,
target,
new object[] {t, y, tp[index]});
return (double) res;
}
protected async override Task OnConsume(string transcriptionId, TaskParameters taskParameters, ClientActiveTasks cleanup)
{
registerTask(cleanup, transcriptionId); // may throw AlreadyInProgress exception
GetLogger().LogInformation($"Creating VTT & SRT files for ({transcriptionId})");
using (var _context = CTDbContext.CreateDbContext())
{
var transcription = await _context.Transcriptions.FindAsync(transcriptionId);
CaptionQueries captionQueries = new CaptionQueries(_context);
var captions = await captionQueries.GetCaptionsAsync(transcription.Id);
var vttfile = await FileRecord.GetNewFileRecordAsync(Caption.GenerateWebVTTFile(captions, transcription.Language), ".vtt");
FileRecord?existingVtt = await _context.FileRecords.FindAsync(transcription.FileId);
if (existingVtt is null)
{
GetLogger().LogInformation($"{transcriptionId}: Creating new vtt file {vttfile.FileName}");
await _context.FileRecords.AddAsync(vttfile);
transcription.File = vttfile;
_context.Entry(transcription).State = EntityState.Modified;
}
else
{
GetLogger().LogInformation($"{transcriptionId}: replacing existing vtt file contents {existingVtt.FileName}");
existingVtt.ReplaceWith(vttfile);
_context.Entry(existingVtt).State = EntityState.Modified;
}
var srtfile = await FileRecord.GetNewFileRecordAsync(Caption.GenerateSrtFile(captions), ".srt");
FileRecord?existingSrt = await _context.FileRecords.FindAsync(transcription.SrtFileId);
if (existingSrt is null)
{
GetLogger().LogInformation($"{transcriptionId}: Creating new srt file {srtfile.FileName}");
await _context.FileRecords.AddAsync(srtfile);
transcription.SrtFile = srtfile;
_context.Entry(transcription).State = EntityState.Modified;
}
else
{
GetLogger().LogInformation($"{transcriptionId}: replacing existing srt file contents {existingSrt.FileName}");
existingSrt.ReplaceWith(srtfile);
_context.Entry(existingSrt).State = EntityState.Modified;
}
await _context.SaveChangesAsync();
GetLogger().LogInformation($"{transcriptionId}: Database updated");
}
}
public void InvokesTaskByWholeName()
{
var task = new MockTask {FullName = "asdf"};
var runner = new TaskRunner();
var taskParameters = new TaskParameters(new Dictionary<string, string>());
runner.RunTask("asdf", taskParameters, new [] {task});
Assert.That(task.WasInvoked, Is.True);
Assert.That(task.WasInvokedWithTaskParameters, Is.SameAs(taskParameters));
}
public void RunTask(string taskName, TaskParameters taskParameters, IEnumerable<ITask> tasks) {
var matchingTasks = tasks.Where(t => AllTaskNames(t).Contains(taskName.ToLower())).ToArray();
if (matchingTasks.Count() > 1) {
throw new AmbiguousTaskNameException(taskName, matchingTasks);
} else if (!matchingTasks.Any()) {
throw new NoMatchingTaskException(taskName, tasks);
} else {
matchingTasks.Single().Invoke(taskParameters);
}
}
public void AsyncAsync()
{
var maxQueue = 10;
var maxTasks = 5000;
var maxSleep = 10;
var IsHighPrority = false;
var result = new ConcurrentDictionary<string, ConcurrentDictionary<string, long>>();
var sw = new Stopwatch();
sw.Start();
var Tasks = new List<Task>();
for (var qNum = 1; qNum <= maxQueue; qNum++)
{
var qName = string.Concat("Q", qNum);
for (var Seq = 1; Seq < maxTasks / maxQueue; Seq++)
{
var taskP = new TaskParameters() { Q = qName, Seq = Seq };
LeveledTask lt = new LeveledTask(async (param) =>
{
// this force the new task not to be inlined.
await Task.Factory.StartNew(async () => { await Task.Delay(100); }, TaskCreationOptions.LongRunning );
var p = param as TaskParameters;
var resultQ = result.GetOrAdd(p.Q, new ConcurrentDictionary<string, long>());
resultQ.AddOrUpdate(string.Concat("S", p.Seq), DateTime.UtcNow.Ticks, (key, current) => { throw new InvalidOperationException("Found existing key"); });
//Trace.WriteLine(string.Format("Task {0} on Queue {1} - Start", p.Seq, p.Q), "info");
Thread.Sleep(maxSleep);
//Trace.WriteLine(string.Format("Task {0} on Queue {1} - End", p.Seq, p.Q), "info");
resultQ.AddOrUpdate(string.Concat("E", p.Seq), DateTime.UtcNow.Ticks, (key, current) => { throw new InvalidOperationException("Found existing key"); });
},
taskP);
lt.QueueId = qName;
lt.IsHighPriority = IsHighPrority;
lt.Start(scheduler);
Tasks.Add(lt);
}
}
Task.WhenAll(Tasks).Wait();
sw.Stop();
Trace.WriteLine(string.Format("{0} Tasks on {1} Queues - Executed in {2} sec", maxTasks, maxQueue, sw.Elapsed.Seconds), "info");
//verify(ref result);
// tasks that uses normal start.run will lose order in the queue.
// the only way that tasks maintain order is to by using
// leveled tasks to create sub tasks.
}
public void InvokesTaskByWholeName()
{
var task = new MockTask {
FullName = "asdf"
};
var runner = new TaskRunner();
var taskParameters = new TaskParameters(new Dictionary <string, string>());
runner.RunTask("asdf", taskParameters, new [] { task });
Assert.That(task.WasInvoked, Is.True);
Assert.That(task.WasInvokedWithTaskParameters, Is.SameAs(taskParameters));
}
public void TestTaskAbortion()
{
var text = string.Concat(Enumerable.Repeat("Test test test, ho ho ho. ", 200500));
const string compressedTxt = "compressed.txt";
File.WriteAllText("in.txt", text);
var parameters = new TaskParameters(ProcessorMode.Compress, "in.txt", compressedTxt);
var processor = new TaskProcessor(new LoggerMock());
var task = processor.Start(parameters);
task.Abort();
task.Wait();
Assert.True(task.IsErrorOccured);
}
private Vector RK4_1(double x, Vector y, double h, int j, TaskParameters taskP)
{
var res = new Vector(2);
Vector f0, f1, f2, f3;
f0 = h * ff(x, y, j, taskP);
f1 = h * ff(x + h / 2, y + f0 / 2, j, taskP);
f2 = h * ff(x + h / 2, y + f1 / 2, j, taskP);
f3 = h * ff(x + h, y + f2, j, taskP);
res = y + (f0 + 2 * f1 + 2 * f2 + f3) / 6;
return(res);
}
public bool Schedule(string name,
ScheduleTaskParallelism parallelism = ScheduleTaskParallelism.AllowOthers)
{
TaskParameters tp = GetNamedTaskParameter(name);
if (tp == null)
{
return(false);
}
tp.TaskName = name;
Schedule(tp, parallelism);
return(true);
}
/// <summary>
/// Create an instance of the specified TaskAdapter class from class name, DLL and path
/// </summary>
/// <param name="task">Configuration object for requested TaskAdapter</param>
private TaskAdapter LoadAdapter(TaskParameters task)
{
// Ensure caller has provided name of class to load:
if (string.IsNullOrEmpty(task.AdapterClassName))
{
throw new LoadAdapterException(10, "TaskAdapter class name not provided");
}
// Build path of adapter DLL, if specified (looking in current folder, if no path provided):
string adapterDLLPath = string.IsNullOrEmpty(task.AdapterDLLName) ? null
: TaskUtilities.General.PathCombine(string.IsNullOrEmpty(task.AdapterDLLPath) ? AppDomain.CurrentDomain.BaseDirectory : task.AdapterDLLPath, task.AdapterDLLName);
try
{
// Load Assembly from DLL name (if provided - otherwise look in "this" Assembly):
var assembly = string.IsNullOrEmpty(adapterDLLPath) ? Assembly.GetExecutingAssembly() : Assembly.LoadFrom(adapterDLLPath);
if (assembly == null)
{
throw BuildLoadAdapterException(11, new ArgumentException("Invalid DLL path/name, or assembly not loaded"), task.AdapterClassName, adapterDLLPath);
}
// Retrieve collection of types from assembly with a base type of TaskAdapter:
var assemblyTypes = assembly.GetTypes()?.Where(t => t.IsSubclassOf(typeof(TaskAdapter)));
if (assemblyTypes?.Any() ?? throw BuildLoadAdapterException(12, new ArgumentException("Assembly contains no TaskAdapters"), task.AdapterClassName, adapterDLLPath))
{
// Locate assembly with matching name (short or fully-qualified):
foreach (var type in assemblyTypes)
{
if (type.FullName.Equals(task.AdapterClassName, StringComparison.OrdinalIgnoreCase) ||
type.Name.Equals(task.AdapterClassName, StringComparison.OrdinalIgnoreCase))
{
// Create TaskAdapter instance (ActivatorUtilities will handle dependency injection, so long as TaskName
// (TaskAdapter constructor argument) is not null (which would confuse activator):
return((TaskAdapter)ActivatorUtilities.CreateInstance(isp, type, task.TaskName ?? string.Empty));
}
}
}
// If this point is reached, class was not found:
throw BuildLoadAdapterException(13, new ArgumentException("Specified class not found in assembly"), task.AdapterClassName, adapterDLLPath);
}
catch (LoadAdapterException)
{
throw;
}
catch (Exception ex)
{
throw BuildLoadAdapterException(14, ex, task.AdapterClassName, adapterDLLPath);
}
}
private double CalcFunct2(TaskParameters taskP)
{
double f = 0;
var val = new List <double>();
var min1List = new List <double>();
var min2List = new List <double>();
var v = new List <Vector>();
double h = res.GetH();
var rk = new Vector[res.Count - 1];
rk[0] = new Vector(2, startP[0], startP[1]);
itab[0] = 1;
double t = res[0].X;
for (int i = 1; i < res.Count - 2; i++)
{
val.Clear();
min1List.Clear();
v.Clear();
for (int j = 0; j < tw.SetCount; j++)
{
//double x2 = rk[i - 1][1] + this.tw.FunctionSet(t, rk[i - 1], j, taskP) * h;
//double x1 = rk[i - 1][0] + x2 * h;
//Vector vv = new Vector(2, x1, x2);
Vector vv = RK4_1(t, rk[i - 1], h, j, taskP);
v.Add(vv);
double min1 = Math.Abs(vv[0] - res[i].Y[0]);
double min2 = Math.Abs(vv[1] - dz[i]);
val.Add(min1 + min2);
min1List.Add(min1);
min2List.Add(min2);
//if (i < this.dz.Length)
//{
// val2.Add(Math.Abs(vv[1] - this.dz[i]));
//}
}
double min = val.Min();
int index = val.IndexOf(min);
rk[i] = v[index];
itab[i] = index + 1;
//f += min * min * h;
f += Math.Pow(min1List[index], 2) + Math.Pow(min2List[index], 2) * h;
t = t + h;
}
return(f);
}
public void Publish(T data, TaskParameters taskParameters = null)
{
try
{
if (taskParameters == null)
{
taskParameters = new TaskParameters();
}
_rabbitMQ.PublishTask(_queueName, data, taskParameters);
}
catch (Exception e)
{
_logger.LogError(e, "Error Publishing Task!");
}
}
public Vector MF2(double t, Vector v, TaskParameters p)
{
var res = new Vector(2);
res[0] = v[1];
if (p.Gamma is List <double> )
{
var pp = new List <double>();
(p.Gamma as List <double>).ForEach(x => pp.Add(x));
pp.Insert(0, double.MinValue);
pp.Add(double.MaxValue);
//double a = double.MinValue;
double b = pp[0];
for (int i = 0; i < pp.Count - 1; i++)
{
if (v[0] > pp[i] && v[0] <= pp[i + 1])
{
res[1] = CallSecFunc(SecFuncName, t, v, p[i]);
}
else
{
continue;
}
}
}
else if (p.Gamma is Dictionary <double, int> )
{
try
{
var tt = p.Gamma as Dictionary <double, int>;
//int i = -1;
double index = tt.Keys.ToList().Find(x => Math.Abs(x - t) < 0.01);
res[1] = CallSecFunc(SecFuncName, t, v, p[tt[index]]);
}
catch
{
res[1] = 1;
}
}
else
{
throw new NotImplementedException("not impl yet");
}
return(res);
}
protected async override Task OnConsume(string transcriptionId, TaskParameters taskParameters, ClientActiveTasks cleanup)
{
registerTask(cleanup, transcriptionId); // may throw AlreadyInProgress exception
using (var _context = CTDbContext.CreateDbContext())
{
var transcription = await _context.Transcriptions.FindAsync(transcriptionId);
FileRecord existingVtt = await _context.FileRecords.FindAsync(transcription.FileId);
FileRecord existingSrt = await _context.FileRecords.FindAsync(transcription.SrtFileId);
CaptionQueries captionQueries = new CaptionQueries(_context);
var captions = await captionQueries.GetCaptionsAsync(transcription.Id);
var vttfile = await FileRecord.GetNewFileRecordAsync(Caption.GenerateWebVTTFile(captions, transcription.Language), ".vtt");
if (string.IsNullOrEmpty(transcription.FileId))
{
await _context.FileRecords.AddAsync(vttfile);
transcription.File = vttfile;
_context.Entry(transcription).State = EntityState.Modified;
}
else
{
existingVtt.ReplaceWith(vttfile);
_context.Entry(existingVtt).State = EntityState.Modified;
}
var srtfile = await FileRecord.GetNewFileRecordAsync(Caption.GenerateSrtFile(captions), ".srt");
if (string.IsNullOrEmpty(transcription.SrtFileId))
{
await _context.FileRecords.AddAsync(srtfile);
transcription.SrtFile = srtfile;
_context.Entry(transcription).State = EntityState.Modified;
}
else
{
existingSrt.ReplaceWith(srtfile);
_context.Entry(existingSrt).State = EntityState.Modified;
}
await _context.SaveChangesAsync();
}
}
/// <summary>
/// Original implementation of OnConsume. This code may be deleted if it is no longer useful. It is left as available for now as a template
/// </summary>
/// <param name="videoId"></param>
/// <param name="taskParameters"></param>
/// <returns></returns>
private async Task OldOnConsumeNotUsed(string videoId, TaskParameters taskParameters)
{
using (var _context = CTDbContext.CreateDbContext())
{
// Get the video object
var video = await _context.Videos.FindAsync(videoId);
_logger.LogInformation("Consuming" + video);
// Make RPC call to produce audio file.
var file = await _rpcClient.PythonServerClient.ConvertVideoToWavRPCWithOffsetAsync(new CTGrpc.FileForConversion
{
File = new CTGrpc.File {
FilePath = video.Video1.VMPath
}
});
// Check if a valid file was returned.
if (FileRecord.IsValidFile(file.FilePath))
{
var fileRecord = await FileRecord.GetNewFileRecordAsync(file.FilePath, file.Ext);
// Get the latest video object, in case it has changed
var videoLatest = await _context.Videos.FindAsync(video.Id);
// If there is no Audio file present, then update.
if (videoLatest.Audio == null)
{
await _context.FileRecords.AddAsync(fileRecord);
videoLatest.Audio = fileRecord;
await _context.SaveChangesAsync();
// If no transcriptions present, produce transcriptions.
if (!videoLatest.Transcriptions.Any())
{
_transcriptionTask.Publish(videoLatest.Id);
}
}
}
else
{
throw new Exception("ConvertVideoToWavTask Failed + " + video.Id);
}
}
}
private List <LeveledTask> createTasks(ref ConcurrentDictionary <string, ConcurrentDictionary <string, long> > allresult,
int maxTasks,
int MaxQueue,
int MaxSleep,
bool isHighPirotiy,
bool randomPrority = false,
int seedID = 0)
{
var sw = new Stopwatch();
sw.Start();
var highProrityTasks = 0;
var normalProrityTasks = 0;
var Tasks = new List <LeveledTask>();
for (var i = seedID + 1; i <= maxTasks + seedID; i++)
{
var q = string.Concat("Q", rnd.Next(1, MaxQueue));
var taskP = new TaskParameters()
{
Q = q, Seq = i
};
var bIsHighPrority = (isHighPirotiy || (randomPrority && rnd.Next(1, int.MaxValue) % 2 == 0));
if (bIsHighPrority)
{
highProrityTasks++;
}
else
{
normalProrityTasks++;
}
// Trace.WriteLine(string.Format("task {0} created on queue {1}", i, q), "info-test");
var lt = addTask(ref allresult, taskP, q, rnd.Next(1, MaxSleep), bIsHighPrority);
Tasks.Add(lt);
}
sw.Stop();
Trace.WriteLine(string.Format("Created N:{0}/H:{1} tasks in {2} ms", normalProrityTasks, highProrityTasks, sw.ElapsedMilliseconds), "info");
return(Tasks);
}
/// <inheritdoc />
public async Task Run(TaskParameters arguments, IProgress <float> progress, CancellationToken cancellationToken)
{
string path = arguments["path"].As <string>();
try
{
progress.Report(0);
Track track = await _identifier.IdentifyTrack(path);
progress.Report(25);
if (track.Episode == null)
{
throw new TaskFailedException($"No episode identified for the track at {path}");
}
if (track.Episode.ID == 0)
{
if (track.Episode.Slug != null)
{
track.Episode = await _libraryManager.Get <Episode>(track.Episode.Slug);
}
else if (track.Episode.Path != null)
{
track.Episode = await _libraryManager.GetOrDefault <Episode>(x => x.Path.StartsWith(track.Episode.Path));
if (track.Episode == null)
{
throw new TaskFailedException($"No episode found for the track at: {path}.");
}
}
else
{
throw new TaskFailedException($"No episode identified for the track at {path}");
}
}
progress.Report(50);
await _libraryManager.Create(track);
progress.Report(100);
}
catch (IdentificationFailedException ex)
{
throw new TaskFailedException(ex);
}
}
/// <summary>
/// Apply all values received in parameters collection to ReturnValue collection
/// </summary>
public override async Task <TaskResult> ExecuteTask(TaskParameters parameters)
{
var result = new TaskResult();
var dateTimeNow = DateTime.Now; // Use single value throughout for consistency in macro replacements
try
{
// Iterate through all keys in incoming parameter collection:
foreach (var key in parameters.GetKeys())
{
// Retrieve specified key value, processing date macros:
var value = parameters.GetString(key, null, dateTimeNow);
// Now process any nested macros in resulting value string - regex will capture argument-named macros,
// to allow keys passed as parameters to this adapter (including the keys of return values output by
// previous adapters in batch) to have their values updated with the value of other keys in collection
// (again including return values output by previous steps). For example, if a previous adapter in this
// batch output a return value of "@FileID"/57, placing the parameter "Command"/"echo <@@FileID>" in
// the collection for THIS adapter will result in value "Command"/"echo 57" being placed in the return
// value collection (and then placed into input parameter collections of subsequent steps):
var valuemacromatches = TaskUtilities.General.REGEX_NESTEDPARM_MACRO
.Matches(value)
.Cast <Match>()
// Flatten match collection into name/value pair and select unique values only:
.Select(match => new { Name = match.Groups["name"].Value, Value = match.Value })
.Distinct();
foreach (var match in valuemacromatches)
{
// Retrieve parameter matching the "name" portion of the macro - processing date/time macros
// again - and replace all instances of the specified macro with the string retrieved:
value = value.Replace(match.Value, parameters.GetString(match.Name, null, dateTimeNow));
}
// Add final value to return value collection:
result.AddReturnValue(key, value);
}
result.Success = true;
}
catch (Exception ex)
{
result.AddException(ex);
}
return(result);
}
/// <inheritdoc />
public Task Run(TaskParameters arguments, IProgress <float> progress, CancellationToken cancellationToken)
{
ICollection <IPlugin> plugins = _pluginManager.GetAllPlugins();
int count = 0;
progress.Report(0);
foreach (IPlugin plugin in plugins)
{
plugin.Initialize(_provider);
progress.Report(count / plugins.Count * 100);
count++;
}
progress.Report(100);
return(Task.CompletedTask);
}
private RKResults DrawRes(RKResults r, RAlgSolver ra, string cn, string cnsuff, Color c, OutputHelper output,
int eb, out double functional)
{
if (!isReal)
{
for (int i = 0; i < r.Count - setCount; i++)
{
if (eb == 1)
{
if (setCount == 1)
{
(tblResList as List<ResPointViewType1>)[i + i*step].M1 = ra.itab[i];
}
else
{
(tblResList as List<ResPointViewType2>)[i + i*step].M1 = ra.itab[i];
}
}
else
{
if (setCount == 1)
{
(tblResList as List<ResPointViewType1>)[i + i*step].M2 = ra.itab[i];
}
else
{
(tblResList as List<ResPointViewType2>)[i + i*step].M2 = ra.itab[i];
}
}
}
grcTabRes.RefreshDataSource();
}
var sb = new StringBuilder();
Dictionary<double, int> tt = GetTT(r, ra.itab);
//-- draw res ---
if (!curves.ContainsKey(cn))
{
curves.Add(cn, new PointPairList());
var curve = new LineItem(cn, curves[cn], c, SymbolType.None);
curve.Line.Style = DashStyle.Dash;
curve.Line.Width = 2;
//this.zgcMainChart2.MasterPane[1].CurveList.Add(curve);
if (setCount == 2)
{
curves.Add(cn + cnsuff, new PointPairList());
var curve1 = new LineItem(cn + cnsuff, curves[cn + cnsuff], c, SymbolType.None);
curve.Line.Style = DashStyle.Dash;
curve.Line.Width = 2;
zgcMainChart2.MasterPane[0].CurveList.Add(curve1);
zgcMainChart2.MasterPane[1].CurveList.Add(curve);
}
else
{
zgcMainChart2.MasterPane[0].CurveList.Add(curve);
}
}
else
{
curves[cn].Clear();
if (setCount == 2)
{
curves[cn + cnsuff].Clear();
}
}
int k = 0;
var listDraw = new List<TaskParameter>();
for (int i = 0; i < tps.Count; i++)
{
var tpDraw = new TaskParameter(tps[i].Param.Length);
string line = string.Format("{0}) ", i);
for (int j = 0; j < tps[0].Param.Length; j++)
{
tpDraw.Param[j] = ra.x[k];
line += string.Format("a{0}={1:f6} ", j, ra.x[k]);
k++;
}
sb.AppendLine(line);
listDraw.Add(tpDraw);
}
sb.AppendLine("-----");
var tps1 = new TaskParameters(listDraw, tt);
var tw1 = new TaskWorker(tps1, funcDescr.GetType(), funcDescr.MainFuncName, funcDescr.SecFuncName, funcDescr);
double t0, t1;
if (!isReal)
{
t0 = double.Parse(txtT0.Text);
t1 = double.Parse(txtT1.Text);
}
else
{
t0 = 0;
t1 = ASignal.Count*0.01;
}
var rk1 = new RKVectorForm(tw1, cn, t0, t1, startVector);
RKResults res1 = rk1.SolveWithConstH(res.Count - 1, RKMetodType.RK2_1);
functional = GetDiff(res, res1);
sb.Append(string.Format("f={0:f6}", functional));
//rtb.Text = sb.ToString();
//this.SetControlFeathe(rtb, "text=", sb.ToString());
output.WriteLine(sb.ToString());
int nn = setCount == 1 ? 1 : 2;
for (int i = 0; i < res1.Count - nn; i++)
{
if (nn == 1)
{
curves[cn].Add(res1[i].X, res1[i].Y[0]);
}
else
{
curves[cn].Add(res1[i].Y[0], res1[i].Y[1]);
curves[cn + cnsuff].Add(res1[i].X, res1[i].Y[0]);
}
}
SetControlProperty(zgcMainChart2, "chart", null);
//this.zgcMainChart2.AxisChange();
//this.zgcMainChart2.Refresh();
return res1;
}
private Vector RK4_1(double x, Vector y, double h, int j, TaskParameters taskP)
{
var res = new Vector(2);
Vector f0, f1, f2, f3;
f0 = h * ff(x, y, j, taskP);
f1 = h * ff(x + h / 2, y + f0 / 2, j, taskP);
f2 = h * ff(x + h / 2, y + f1 / 2, j, taskP);
f3 = h * ff(x + h, y + f2, j, taskP);
res = y + (f0 + 2 * f1 + 2 * f2 + f3) / 6;
return res;
}
private RAlgSolver(TaskWorker tw, RKResults res, List<List<double>> startParameters)
{
this.tw = tw;
this.res = res;
itab = new int[res.Count - 1];
if (res[0].Y.Count == 2)
{
var dz1 = new double[res.Count - 1];
for (int i = 1; i < res.Count; i++)
{
dz1[i - 1] = (res[i].Y[0] - res[i - 1].Y[0]) / (res[i].X - res[i - 1].X);
}
var dz2 = new double[res.Count - 2];
for (int i = 1; i < dz1.Length; i++)
{
dz2[i - 1] = (dz1[i] - dz1[i - 1]) / (res[i].X - res[i - 1].X);
}
dz = dz2;
}
var list = new List<TaskParameter>();
int k = 0;
for (int i = 0; i < startParameters.Count; i++)
{
var tp1 = new TaskParameter(startParameters[i].Count);
for (int j = 0; j < startParameters[i].Count; j++)
{
x[k] = startParameters[i][j];
tp1.Param[j] = x[k];
k++;
}
list.Add(tp1);
}
c = k;
tp = new TaskParameters(list, double.MinValue);
}
public Vector MF1(double t, Vector v, TaskParameters p)
{
var res = new Vector(1);
if (p.Gamma is List<double>)
{
var pp = new List<double>();
(p.Gamma as List<double>).ForEach(x => pp.Add(x));
pp.Insert(0, double.MinValue);
pp.Add(double.MaxValue);
//double a = double.MinValue;
double b = pp[0];
for (int i = 0; i < pp.Count - 1; i++)
{
if (v[0] > pp[i] && v[0] <= pp[i + 1])
{
res[0] = CallSecFunc(SecFuncName, t, v, p[i]);
}
else
continue;
}
}
else if (p.Gamma is Dictionary<double, int>)
{
try
{
var tt = p.Gamma as Dictionary<double, int>;
//int i = -1;
double index = tt.Keys.ToList().Find(x => Math.Abs(x - t) < 0.01);
res[0] = CallSecFunc(SecFuncName, t, v, p[tt[index]]);
}
catch (Exception)
{
res[0] = 1;
}
}
else
throw new NotImplementedException("not impl yet");
return res;
}
/// <summary>
/// This method is only for paramteter customizing (merge with Schedule(string name, ?)
/// TaskName should be preinitialized and point to existing named tp in container.
/// </summary>
/// <param name="tp"></param>
/// <param name="parallelism"></param>
/// <param name="dueInSeconds"></param>
protected void Schedule(TaskParameters tp,
ScheduleTaskParallelism parallelism = ScheduleTaskParallelism.AllowOthers,
int dueInSeconds = 0)
{
lock (runningTasks)
{
if (!IsStarted) throw new InvalidOperationException("Task scheduler is not running");
log.Info("Scheduling "+tp);
var entity = new ScheduleEntity()
{
NextExecution = DateTime.MaxValue,
Parallelism = parallelism,
TaskName = tp.TaskName,
};
lock (repoLocker)
{
repo.Save(entity);
repo.LoadSettingsIfNull(entity);
foreach (KeyValuePair<string, object> setting in tp.Settings)
{
entity.Settings.AddEntry(setting.Key, setting.Value);
}
entity.NextExecution = DateTime.Now.AddSeconds(Math.Max(0, dueInSeconds));
repo.Update(entity);
}
}
}
public void ThrowsExceptionWhenStringParameterIsNotPresentWithType()
{
var p = new TaskParameters(new Dictionary<string, string>());
Assert.That(() => p.Parameter(typeof(string), "file"), Throws.InstanceOf<RequiredParameterNotGivenException>());
}
private void btnSolveRK_Click(object sender, EventArgs e)
{
try
{
btnSolveRK.Enabled = false;
isReal = false;
view.Output.ClearScreen();
grcTabRes.DataSource = null;
n = int.Parse(txtN.Text, enUsCulture);
setCount = rbN1.Checked ? 1 : 2;
//this.gamma = double.Parse(txtGamma.Text);
if (setCount == 1)
{
view.ConfigGraphPane(zgcMainChart2, this, PaneLayout.SingleColumn, new List<ChartInfo>
{
new ChartInfo
{
Title = "(t,z1)",
XAxisTitle = "t",
YAxisTitle = "z1"
},
});
}
else
{
view.ConfigGraphPane(zgcMainChart2, this, PaneLayout.SingleColumn, new List<ChartInfo>
{
new ChartInfo
{
Title = "(t,z1)",
XAxisTitle = "t",
YAxisTitle = "z1"
},
new ChartInfo
{
Title = "(z1,z2)",
XAxisTitle = "z1",
YAxisTitle = "z2"
}
});
}
//ZedGraph.GraphPane gp = this.zgcMainChart2.GraphPane;
//gp.CurveList.Clear();
curves.Clear();
if (setCount == 1)
{
curves.Add(curveName, new PointPairList());
zgcMainChart2.MasterPane[0].AddCurve(curveName, curves[curveName], Color.Black, SymbolType.None);
}
else
{
curves.Add(curveName, new PointPairList());
curves.Add(curveName + curveNameSuff, new PointPairList());
zgcMainChart2.MasterPane[0].AddCurve(curveName + curveNameSuff, curves[curveName + curveNameSuff],
Color.Black, SymbolType.None);
zgcMainChart2.MasterPane[1].AddCurve(curveName, curves[curveName], Color.Black, SymbolType.None);
}
var p = new List<double>();
var gammaList = new List<double>();
for (int i = 0; i < dgvGama.ColumnCount; i++)
{
double d = double.Parse(dgvGama.Rows[0].Cells[i].Value.ToString().Replace(',', '.'), enUsCulture);
gammaList.Add(d);
}
var list = new List<TaskParameter>();
for (int i = 0; i < dgvParameters.RowCount; i++)
{
var tp = new TaskParameter(dgvParameters.ColumnCount);
for (int j = 0; j < dgvParameters.ColumnCount; j++)
{
double val = double.Parse(dgvParameters.Rows[i].Cells[j].Value.ToString().Replace(',', '.'),
enUsCulture);
tp.Param[j] = val;
}
list.Add(tp);
}
tps = new TaskParameters(list, gammaList);
string mfName = setCount == 1 ? "MF1" : "MF2";
funcDescr = new Functions_2_2(mfName, fnames[(sfList.SelectedItem as string).ToUpper()]);
tw = new TaskWorker(tps, funcDescr.GetType(), funcDescr.MainFuncName, funcDescr.SecFuncName, funcDescr);
startVector = setCount == 1
? new Vector(1, double.Parse(txtY0.Text.Replace(',', '.'), enUsCulture))
: new Vector(2, double.Parse(txtY00.Text.Replace(',', '.'), enUsCulture),
double.Parse(txtY01.Text.Replace(',', '.'), enUsCulture));
var rk = new RKVectorForm(tw, curveName, double.Parse(txtT0.Text.Replace(',', '.'), enUsCulture),
double.Parse(txtT1.Text.Replace(',', '.'), enUsCulture), startVector);
res = rk.SolveWithConstH(n, RKMetodType.RK4_1);
if (rbN1.Checked)
{
for (int i = 0; i < res.Count - 1; i++)
{
curves[curveName].Add(res[i].X, res[i].Y[0]);
}
//res.ForEach(r => this.curves[curveName].Add(r.X, r.Y[0]));
}
else
{
for (int i = 0; i < res.Count - 2; i++)
{
curves[curveName + curveNameSuff].Add(res[i].X, res[i].Y[0]);
curves[curveName].Add(res[i].Y[0], res[i].Y[1]);
}
//res.ForEach(r => this.curves[curveName].Add(r.Y[0], r.Y[1]));
}
zgcMainChart2.AxisChange();
zgcMainChart2.Refresh();
if (setCount == 1)
{
tblResList = new List<ResPointViewType1>();
for (int i = 0; i < res.Count - 1; i++)
(tblResList as List<ResPointViewType1>).Add(new ResPointViewType1(res[i].X, res[i].Y[0], -1, -1));
grcTabRes.DataSource = null;
grcTabRes.DataSource = tblResList;
}
else
{
tblResList = new List<ResPointViewType2>();
for (int i = 0; i < res.Count - 2; i++)
(tblResList as List<ResPointViewType2>).Add(new ResPointViewType2(res[i].X, res[i].Y[0],
res[i].Y[1], -1, -1));
grcTabRes.DataSource = null;
grcTabRes.DataSource = tblResList;
}
grcTabRes.RefreshDataSource();
}
finally
{
btnSolveRK.Enabled = true;
}
}
private void btnSolveRK_Click(object sender, EventArgs e)
{
this.rtbResult1.Text = this.rtbResult2.Text = string.Empty;
this.dgvTabRes.DataSource = null;
this.n = int.Parse(this.txtN.Text);
this.setCount = this.rbN1.Checked ? 1 : 2;
//this.gamma = double.Parse(txtGamma.Text);
ZedGraph.GraphPane gp = this.zgcMainChart2.GraphPane;
gp.CurveList.Clear();
this.curves.Clear();
this.curves.Add(this.curveName, new PointPairList());
gp.AddCurve(this.curveName, this.curves[curveName], Color.Black, SymbolType.None);
List<double> gammaList = new List<double>();
List<double> p = new List<double>();
for (int i = 0; i < dgvGama.ColumnCount; i++)
{
gammaList.Add(Convert.ToDouble(dgvGama.Rows[0].Cells[i].Value));
}
List<TaskParameter> list = new List<TaskParameter>();
for (int i = 0; i < dgvParameters.RowCount; i++)
{
TaskParameter tp = new TaskParameter(dgvParameters.ColumnCount);
for (int j = 0; j < dgvParameters.ColumnCount; j++)
{
double val = Convert.ToDouble(dgvParameters.Rows[i].Cells[j].Value);
tp.Param[j] = val;
}
list.Add(tp);
}
this.tps = new TaskParameters(list, gammaList);
string mfName = this.setCount == 1 ? "MF1" : "MF2";
this.funcDescr = new Functions_2_2(mfName, this.fnames[(sfList.SelectedItem as string).ToUpper()]);
this.tw = new TaskWorker(tps, funcDescr.GetType(), funcDescr.MainFuncName, funcDescr.SecFuncName, funcDescr);
this.startVector = this.setCount == 1 ? new Vector(1, double.Parse(this.txtY0.Text)) :
new Vector(2, double.Parse(this.txtY00.Text), double.Parse(this.txtY01.Text));
RKVectorForm rk = new RKVectorForm(tw, curveName, double.Parse(this.txtT0.Text), double.Parse(this.txtT1.Text), startVector);
this.res = rk.SolveWithConstH(n, RKMetodType.RK4_1);
if (this.rbN1.Checked)
{
res.ForEach(r => this.curves[curveName].Add(r.X, r.Y[0]));
}
else
{
res.ForEach(r => this.curves[curveName].Add(r.Y[0], r.Y[1]));
}
this.zgcMainChart2.AxisChange();
this.zgcMainChart2.Refresh();
if (this.setCount == 1)
{
this.tblResList = new List<ResPointViewType1>();
for (int i = 0; i < res.Count - 1; i++)
(this.tblResList as List<ResPointViewType1>).Add(new ResPointViewType1(res[i].X, res[i].Y[0], -1, -1));
this.dgvTabRes.DataSource = null;
this.dgvTabRes.DataSource = tblResList;
}
else
{
this.tblResList = new List<ResPointViewType2>();
for (int i = 0; i < res.Count - 2; i++)
(this.tblResList as List<ResPointViewType2>).Add(new ResPointViewType2(res[i].X, res[i].Y[0], res[i].Y[1], -1, -1));
this.dgvTabRes.DataSource = null;
this.dgvTabRes.DataSource = tblResList;
}
this.dgvTabRes.RefreshDataSource();
this.randomStartParameters = this.GetRandomStartParam();
}
private Vector ff(double t, Vector y, int j, TaskParameters taskP)
{
return new Vector(2, y[1], tw.FunctionSet(t, y, j, taskP));
}
public void CanParseDefaultStringParameter()
{
var p = new TaskParameters(new Dictionary<string, string> {{"file", "thefile.txt"}});
Assert.That(p.Parameter("file", "afile.txt"), Is.EqualTo("thefile.txt"));
}
protected void lnkBreakWithCopy_Click(Object sender, EventArgs e)
{
// Check permission
CanModifyPermission(true);
// Break permission inheritance and copy parent permissions
AclProvider.BreakInherintance(Node, true);
// Log staging task
TaskParameters taskParam = new TaskParameters();
taskParam.SetParameter("copyPermissions", true);
DocumentSynchronizationHelper.LogDocumentChange(Node, TaskTypeEnum.BreakACLInheritance, Node.TreeProvider, SynchronizationInfoProvider.ENABLED_SERVERS, taskParam, Node.TreeProvider.AllowAsyncActions);
// Insert information about this event to eventlog.
if (Tree.LogEvents)
{
EventLog.LogEvent(EventLogProvider.EVENT_TYPE_INFORMATION, DateTime.Now, "Content", "DOCPERMISSIONSMODIFIED", Tree.UserInfo.UserID, Tree.UserInfo.UserName, Node.NodeID, DocumentName, ipAddress, ResHelper.GetAPIString("security.documentpermissionsbreakcopy", "Inheritance of the parent document permissions have been broken. Parent document permissions have been copied."), Node.NodeSiteID, eventUrl);
}
lblInheritanceInfo.Text = GetString("Security.InheritsInfo.DoesNotInherit");
SwitchBackToPermissionsMode();
// Clear and reload
securityElem.InvalidateAcls();
securityElem.LoadOperators(true);
}
private double CalcFunct1(TaskParameters taskP)
{
double f = 0;
var val = new List<double>();
var v = new List<Vector>();
double h = res.GetH();
var rk = new Vector[res.Count - 1];
rk[0] = new Vector(1, startP[0]);
itab[0] = 1;
double t = res[0].X;
for (int i = 1; i < res.Count - 1; i++)
{
val.Clear();
v.Clear();
for (int j = 0; j < tw.SetCount; j++)
{
double x1 = rk[i - 1][0] + tw.FunctionSet(t, rk[i - 1], j, taskP) * h;
v.Add(new Vector(1, x1));
val.Add(Math.Abs(x1 - res[i].Y[0]));
}
double min = val.Min();
int index = val.IndexOf(min);
rk[i] = v[index];
itab[i] = index + 1;
f += min * min * h;
t = t + h;
}
return f;
}
public void Task_T()
{
var maxQueue = 10;
var maxTasks = 5000;
var maxSleep = 10;
var IsHighPrority = false;
var result = new ConcurrentDictionary<string, ConcurrentDictionary<string, long>>();
var sw = new Stopwatch();
sw.Start();
var Tasks = new List<Task<long>>();
for (var qNum = 1; qNum <= maxQueue; qNum++)
{
var qName = string.Concat("Q", qNum);
for (var Seq = 1; Seq < maxTasks / maxQueue; Seq++)
{
var taskP = new TaskParameters() { Q = qName, Seq = Seq };
LeveledTask<long> lt = new LeveledTask<long>( (param) =>
{
// this force the new task not to be inlined.
var p = param as TaskParameters;
var resultQ = result.GetOrAdd(p.Q, new ConcurrentDictionary<string, long>());
resultQ.AddOrUpdate(string.Concat("S", p.Seq), DateTime.UtcNow.Ticks, (key, current) => { throw new InvalidOperationException("Found existing key"); });
//Trace.WriteLine(string.Format("Task {0} on Queue {1} - Start", p.Seq, p.Q), "info");
Thread.Sleep(maxSleep);
//Trace.WriteLine(string.Format("Task {0} on Queue {1} - End", p.Seq, p.Q), "info");
resultQ.AddOrUpdate(string.Concat("E", p.Seq), DateTime.UtcNow.Ticks, (key, current) => { throw new InvalidOperationException("Found existing key"); });
return DateTime.Now.Ticks;
},
taskP);
lt.QueueId = qName;
lt.IsHighPriority = IsHighPrority;
lt.Start(scheduler);
Tasks.Add(lt);
}
}
Task.WhenAll(Tasks).Wait();
foreach (var task in Tasks)
Trace.WriteLine(String.Format("Task result was:{0} ", task.Result));
sw.Stop();
Trace.WriteLine(string.Format("{0} Tasks on {1} Queues - Executed in {2} sec", maxTasks, maxQueue, sw.Elapsed.Seconds), "info");
verify(ref result);
}
private void btnTransfer_Click(object sender, EventArgs e)
{
isReal = true;
view.Output.ClearScreen();
grcTabRes.DataSource = null;
n = int.Parse(txtN.Text);
setCount = rbN1.Checked ? 1 : 2;
double t = 0;
var r = new RKResults();
foreach (double y in ASignal)
{
r.Add(new RKResult(t, new Vector(1, y)));
t += 0.01;
}
res = r;
randomStartParameters = GetRandomStartParam();
var gammaList = new List<double>();
for (int i = 0; i < dgvGama.ColumnCount; i++)
{
gammaList.Add(Convert.ToDouble(dgvGama.Rows[0].Cells[i].Value));
}
var list = new List<TaskParameter>();
for (int i = 0; i < dgvParameters.RowCount; i++)
{
var tp = new TaskParameter(dgvParameters.ColumnCount);
for (int j = 0; j < dgvParameters.ColumnCount; j++)
{
double val = Convert.ToDouble(dgvParameters.Rows[i].Cells[j].Value);
tp.Param[j] = val;
}
list.Add(tp);
}
tps = new TaskParameters(list, gammaList);
string mfName = setCount == 1 ? "MF1" : "MF2";
funcDescr = new Functions_2_2(mfName, fnames[(sfList.SelectedItem as string).ToUpper()]);
startVector = new Vector(1, 0);
tw = new TaskWorker(tps, funcDescr.GetType(), funcDescr.MainFuncName, funcDescr.SecFuncName, funcDescr);
xtcMain.SelectedTabPageIndex = 2;
}
public double Integral(TaskParameters taskP)
{
lambda = new int[taskP.Count, dz.Length];
itab = new int[dz.Length];
var diffValues = new List<double>();
int k;
for (int i = 0; i < dz.Length; i++)
{
diffValues.Clear();
for (int j = 0; j < tw.SetCount; j++)
{
double d = Math.Abs(dz[i] - tw.FunctionSet(res[i].X, res[i].Y, j, taskP));
diffValues.Add(d);
}
k = diffValues.IndexOf(diffValues.Min());
for (int j = 0; j < tw.SetCount; j++)
{
lambda[j, i] = j == k ? 1 : 0;
}
itab[i] = k + 1;
}
double val = 0;
for (int i = 0; i < dz.Length - 1; i++)
{
for (int j = 0; j < tw.SetCount; j++)
{
val += lambda[j, i] * Math.Pow(dz[i] - tw.FunctionSet(res[i].X, res[i].Y, j, taskP), 2);
}
}
val *= res.GetH();
return val;
}
public void CanParseDefaultStringParameterIfNotPresentWithType()
{
var p = new TaskParameters(new Dictionary<string, string>());
Assert.That(p.Parameter(typeof(string), "file", "afile.txt"), Is.EqualTo("afile.txt"));
}
public void Invoke(TaskParameters taskParameters) {
WasInvoked = true;
WasInvokedWithTaskParameters = taskParameters;
}
private void btnSolveRAlg2_Click(object sender, EventArgs e)
{
try
{
this.btnSolveRAlg2.Enabled = false;
int tick = Environment.TickCount;
this.inf2 = null;
//List<List<double>> sp = this.GetRandomStartParam();
List<List<double>> sp = this.randomStartParameters;
RAlgSolver ra = new RAlgSolver(this.tw, this.res, sp, this.startVector);
ra.FUNCT = new RAlgSolver.FUNCTDelegate(ra.FUNCT4);
ra.R_Algorithm();
for (int i = 0; i < res.Count - this.setCount; i++)
{
if (this.setCount == 1)
{
(this.tblResList as List<ResPointViewType1>)[i].M2 = ra.itab[i];
}
else
{
(this.tblResList as List<ResPointViewType2>)[i].M2 = ra.itab[i];
}
}
this.dgvTabRes.RefreshDataSource();
Dictionary<double, int> tt = this.GetTT(this.res, ra.itab);
StringBuilder sb = new StringBuilder();
//-- draw res ---
if (!this.curves.ContainsKey(this.curveName2))
{
this.curves.Add(this.curveName2, new PointPairList());
LineItem curve = new LineItem(this.curveName2, this.curves[curveName2], Color.Blue, SymbolType.None);
curve.Line.Style = System.Drawing.Drawing2D.DashStyle.DashDot;
curve.Line.Width = 2;
this.zgcMainChart2.GraphPane.CurveList.Add(curve);
}
else
{
this.curves[this.curveName2].Clear();
}
int k = 0;
List<TaskParameter> listDraw = new List<TaskParameter>();
for (int i = 0; i < tps.Count; i++)
{
TaskParameter tpDraw = new TaskParameter(tps[i].Param.Length);
string line = string.Format("{0}) ", i);
for (int j = 0; j < tps[0].Param.Length; j++)
{
tpDraw.Param[j] = ra.x[k];
line += string.Format("a{0}={1:f6} ", j, ra.x[k]);
k++;
}
sb.AppendLine(line);
listDraw.Add(tpDraw);
}
sb.AppendLine("-----");
sb.Append(string.Format("f={0}", ra.f));
rtbResult2.Text = sb.ToString();
TaskParameters tps1 = new TaskParameters(listDraw, tt);
TaskWorker tw1 = new TaskWorker(tps1, this.funcDescr.GetType(), this.funcDescr.MainFuncName, this.funcDescr.SecFuncName, this.funcDescr);
RKVectorForm rk1 = new RKVectorForm(tw1, curveName2, double.Parse(this.txtT0.Text), double.Parse(this.txtT1.Text), this.startVector);
RKResults res1 = rk1.SolveWithConstH(n, RKMetodType.RK2_1);
//if (this.setCount == 1)
//{
// res1.ForEach(r => this.curves[this.curveName2].Add(r.X, r.Y[0]));
//}
//else
//{
// res1.ForEach(r => this.curves[this.curveName2].Add(r.Y[0], r.Y[1]));
//}
int nn = this.setCount == 1 ? 1 : 2;
for (int i = 0; i < res1.Count - nn; i++)
{
if (nn == 1)
{
this.curves[curveName2].Add(res1[i].X, res1[i].Y[0]);
}
else
{
this.curves[curveName2].Add(res1[i].Y[0], res1[i].Y[1]);
}
}
this.zgcMainChart2.AxisChange();
this.zgcMainChart2.Refresh();
this.ra2 = ra;
double t = ((Environment.TickCount - tick) / (double)1000);
this.rtbResult2.Text += string.Format("\r\n-----\r\ntime = {0} sec", t);
this.inf2 = string.Format("Result: f = {0:f6} time = {1} sec", ra.f, t);
}
finally
{
this.btnSolveRAlg2.Enabled = true;
}
}
public void CanParseEnumeration()
{
var p = new TaskParameters(new Dictionary<string, string> { { "lake", "constance" } });
Assert.That(p.Parameter<Lakes>("lake"), Is.EqualTo(Lakes.Constance));
}
private LeveledTask addTask(ref ConcurrentDictionary<string, ConcurrentDictionary<string, long>> allresult ,
TaskParameters taskP,
string q,
int maxSleep,
bool IsHighPrority = false)
{
var result = allresult;
LeveledTask lt = new LeveledTask((param) =>
{
var p = param as TaskParameters;
var resultQ = result.GetOrAdd(p.Q, new ConcurrentDictionary<string, long>());
resultQ.AddOrUpdate(string.Concat("S", p.Seq), DateTime.UtcNow.Ticks, (key, current) => { throw new InvalidOperationException("Found existing key"); });
//Trace.WriteLine(string.Format("Task {0} on Queue {1} - Start", p.Seq, p.Q), "info");
Thread.Sleep(maxSleep);
//Trace.WriteLine(string.Format("Task {0} on Queue {1} - End", p.Seq, p.Q), "info");
resultQ.AddOrUpdate(string.Concat("E", p.Seq), DateTime.UtcNow.Ticks, (key, current) => { throw new InvalidOperationException("Found existing key"); });
},
taskP);
lt.QueueId = q;
lt.IsHighPriority = IsHighPrority;
lt.Start(scheduler);
return lt;
}
public void CanParseStringParameterWithType()
{
var p = new TaskParameters(new Dictionary<string, string> { { "file", "thefile.txt" } });
Assert.That(p.Parameter(typeof(string), "file", "afile.txt"), Is.EqualTo("thefile.txt"));
}
private List<LeveledTask> createTasks(ref ConcurrentDictionary<string, ConcurrentDictionary<string, long>> allresult,
int maxTasks,
int MaxQueue,
int MaxSleep,
bool isHighPirotiy,
bool randomPrority = false,
int seedID = 0)
{
var sw = new Stopwatch();
sw.Start();
var highProrityTasks = 0;
var normalProrityTasks = 0;
var Tasks = new List<LeveledTask>();
for (var i = seedID + 1; i <= maxTasks + seedID; i++)
{
var q = string.Concat("Q", rnd.Next(1, MaxQueue));
var taskP = new TaskParameters() { Q = q, Seq = i };
var bIsHighPrority = (isHighPirotiy || (randomPrority && rnd.Next(1, int.MaxValue) % 2 == 0));
if (bIsHighPrority)
highProrityTasks++;
else
normalProrityTasks++;
// Trace.WriteLine(string.Format("task {0} created on queue {1}", i, q), "info-test");
var lt = addTask(ref allresult, taskP, q, rnd.Next(1, MaxSleep), bIsHighPrority);
Tasks.Add(lt);
}
sw.Stop();
Trace.WriteLine(string.Format("Created N:{0}/H:{1} tasks in {2} ms", normalProrityTasks, highProrityTasks, sw.ElapsedMilliseconds), "info");
return Tasks;
}
private double CalcFunct2_1(TaskParameters taskP)
{
double f = 0;
var val = new List<double>();
var min1List = new List<double>();
//List<double> min2List = new List<double>();
var v = new List<Vector>();
double h = res.GetH();
var rk = new Vector[res.Count - 1];
rk[0] = new Vector(2, startP[0], startP[1]);
itab[0] = 1;
double t = res[0].X;
for (int i = 1; i < res.Count - 2; i++)
{
val.Clear();
min1List.Clear();
v.Clear();
for (int j = 0; j < tw.SetCount; j++)
{
Vector vv = RK4_1(t, rk[i - 1], h, j, taskP);
v.Add(vv);
double min1 = Math.Abs(vv[0] - res[i].Y[0]);
//double min2 = Math.Abs(vv[1] - this.dz[i]);
val.Add(min1);
min1List.Add(min1);
//min2List.Add(min2);
//if (i < this.dz.Length)
//{
// val2.Add(Math.Abs(vv[1] - this.dz[i]));
//}
}
double min = val.Min();
int index = val.IndexOf(min);
rk[i] = v[index];
itab[i] = index + 1;
//f += min * min * h;
f += (Math.Pow(min1List[index], 2) + alpha * (v[index][0] * v[index][0] + v[index][1] * v[index][1])) * h;
t = t + h;
}
return f;
}
