public DecisionMakerType1(
List<FuzzyVariable> inputVariables,
FuzzyVariable outputVariable,
RulesList ruleDefinitions,
List<string> includedVariables = null)
{
if (includedVariables == null)
{
includedVariables = (from v in inputVariables select v.Name).ToList();
}
this.fsWellEval = new MamdaniFuzzySystem();
this.fsWellEval.Input.AddRange(from v in inputVariables where includedVariables.Contains(v.Name) select v);
this.fsWellEval.Output.Add(outputVariable);
this.RulesDefinitions = new RulesList();
foreach (var rule in ruleDefinitions.Items)
{
string[] splitDef = rule.Definition.Split(
new[] { "if", "and", "(", ")" },
StringSplitOptions.RemoveEmptyEntries);
string updatedDef = string.Empty;
foreach (var condition in splitDef)
{
if (condition == string.Empty)
{
continue;
}
var trimmedCondition = condition.Trim();
if (trimmedCondition.StartsWith("then"))
{
updatedDef += trimmedCondition;
}
else
{
string variable = trimmedCondition.Split(' ')[0];
if (includedVariables.Contains(variable))
{
string keyword = updatedDef == string.Empty ? "if" : "and";
updatedDef += string.Format("{0} ({1}) ", keyword, trimmedCondition);
}
}
}
if (!RulesDefinitions.Items.Exists(r => r.Definition.Equals(updatedDef)))
{
this.RulesDefinitions.Items.Add(new RuleDef { Definition = updatedDef, Weight = rule.Weight });
MamdaniFuzzyRule newRule = this.fsWellEval.ParseRule(updatedDef);
this.fsWellEval.Rules.Add(newRule);
}
}
}
public ZonesSelectationViewModel(List<GKZone> zones, bool canCreateNew = false)
{
Title = "Выбор зон";
AddCommand = new RelayCommand<object>(OnAdd, CanAdd);
RemoveCommand = new RelayCommand<object>(OnRemove, CanRemove);
AddAllCommand = new RelayCommand(OnAddAll, CanAddAll);
RemoveAllCommand = new RelayCommand(OnRemoveAll, CanRemoveAll);
CreateNewCommand = new RelayCommand(OnCreateNew);
Zones = zones;
CanCreateNew = canCreateNew;
TargetZones = new SortableObservableCollection<GKZone>();
SourceZones = new SortableObservableCollection<GKZone>();
foreach (var zone in GKManager.DeviceConfiguration.SortedZones)
{
if (Zones.Contains(zone))
TargetZones.Add(zone);
else
SourceZones.Add(zone);
}
TargetZones.Sort(x => x.No);
SourceZones.Sort(x => x.No);
SelectedTargetZone = TargetZones.FirstOrDefault();
SelectedSourceZone = SourceZones.FirstOrDefault();
}
public ITurn ChooseTurn(IPlayerState playerState, IPlayerState opponentState)
{
var canSwitchNeuromon = playerState.InactiveNeuromon.Any(n => !n.IsDead);
var validTurnTypes = new List<int>
{
AttackTurnType
};
var sb = new StringBuilder();
sb.AppendLine("1: Attack");
if (canSwitchNeuromon)
{
sb.AppendLine("2: Change Neuromon");
validTurnTypes.Add(ChangeNeuromonTurnType);
}
Console.WriteLine(sb.ToString());
ITurn selectedTurn = null;
var turnType = ReadInputUntilValid(input => validTurnTypes.Contains(input));
if (turnType == AttackTurnType)
{
selectedTurn = ChooseAttack(playerState.ActiveNeuromon);
}
else if (turnType == ChangeNeuromonTurnType && canSwitchNeuromon)
{
selectedTurn = new SwitchActiveNeuromon(SelectActiveNeuromon(playerState, opponentState));
}
return selectedTurn;
}
public MPTsSelectationViewModel(List<GKMPT> mpts, bool canCreateNew = false)
{
Title = "Выбор МПТ";
AddCommand = new RelayCommand<object>(OnAdd, CanAdd);
RemoveCommand = new RelayCommand<object>(OnRemove, CanRemove);
AddAllCommand = new RelayCommand(OnAddAll, CanAddAll);
RemoveAllCommand = new RelayCommand(OnRemoveAll, CanRemoveAll);
CreateNewCommand = new RelayCommand(OnCreateNew);
MPTs = mpts;
CanCreateNew = canCreateNew;
TargetMPTs = new SortableObservableCollection<GKMPT>();
SourceMPTs = new SortableObservableCollection<GKMPT>();
foreach (var mpt in GKManager.DeviceConfiguration.MPTs)
{
if (MPTs.Contains(mpt))
TargetMPTs.Add(mpt);
else
SourceMPTs.Add(mpt);
}
TargetMPTs.Sort(x => x.No);
SourceMPTs.Sort(x => x.No);
SelectedTargetMPT = TargetMPTs.FirstOrDefault();
SelectedSourceMPT = SourceMPTs.FirstOrDefault();
}
public DirectionsSelectationViewModel(List<GKDirection> directions)
{
Title = "Выбор направлений";
AddCommand = new RelayCommand<object>(OnAdd, CanAdd);
RemoveCommand = new RelayCommand<object>(OnRemove, CanRemove);
AddAllCommand = new RelayCommand(OnAddAll, CanAddAll);
RemoveAllCommand = new RelayCommand(OnRemoveAll, CanRemoveAll);
CreateNewCommand = new RelayCommand(OnCreateNew);
Directions = directions;
TargetDirections = new SortableObservableCollection<GKDirection>();
SourceDirections = new SortableObservableCollection<GKDirection>();
foreach (var direction in GKManager.Directions)
{
if (Directions.Contains(direction))
TargetDirections.Add(direction);
else
SourceDirections.Add(direction);
}
TargetDirections.Sort(x => x.No);
SourceDirections.Sort(x => x.No);
SelectedTargetDirection = TargetDirections.FirstOrDefault();
SelectedSourceDirection = SourceDirections.FirstOrDefault();
}
public GuardZonesSelectationViewModel(List<GKGuardZone> guardZones)
{
Title = "Выбор охранных зон";
AddCommand = new RelayCommand<object>(OnAdd, CanAdd);
RemoveCommand = new RelayCommand<object>(OnRemove, CanRemove);
AddAllCommand = new RelayCommand(OnAddAll, CanAddAll);
RemoveAllCommand = new RelayCommand(OnRemoveAll, CanRemoveAll);
CreateNewCommand = new RelayCommand(OnCreateNew);
GuardZones = guardZones;
TargetZones = new SortableObservableCollection<GKGuardZone>();
SourceZones = new SortableObservableCollection<GKGuardZone>();
foreach (var guardZone in GKManager.GuardZones)
{
if (GuardZones.Contains(guardZone))
TargetZones.Add(guardZone);
else
SourceZones.Add(guardZone);
}
TargetZones.Sort(x => x.No);
SourceZones.Sort(x => x.No);
SelectedTargetZone = TargetZones.FirstOrDefault();
SelectedSourceZone = SourceZones.FirstOrDefault();
}
public PumpStationsSelectationViewModel(List<GKPumpStation> pumpStations)
{
Title = "Выбор насосных станций";
AddCommand = new RelayCommand<object>(OnAdd, CanAdd);
RemoveCommand = new RelayCommand<object>(OnRemove, CanRemove);
AddAllCommand = new RelayCommand(OnAddAll, CanAddAll);
RemoveAllCommand = new RelayCommand(OnRemoveAll, CanRemoveAll);
CreateNewCommand = new RelayCommand(OnCreateNew);
PumpStations = pumpStations;
TargetPumpStations = new SortableObservableCollection<GKPumpStation>();
SourcePumpStations = new SortableObservableCollection<GKPumpStation>();
foreach (var pumpStation in GKManager.PumpStations)
{
if (PumpStations.Contains(pumpStation))
TargetPumpStations.Add(pumpStation);
else
SourcePumpStations.Add(pumpStation);
}
TargetPumpStations.Sort(x => x.No);
SourcePumpStations.Sort(x => x.No);
SelectedTargetPumpStation = TargetPumpStations.FirstOrDefault();
SelectedSourcePumpStation = SourcePumpStations.FirstOrDefault();
}
static void Main(string[] args)
{
PrimeCalculator calc = new PrimeCalculator();
calc.GetAllPrimes(10000);
for (int n = 1000; n < 10000; n++)
{
int d1 = n % 10;
int d2 = (n / 10) % 10;
int d3 = (n / 100) % 10;
int d4 = n / 1000;
var permutations = Permutator.Permutate(new int[] {d1, d2, d3, d4}.ToList());
var numbers = new List<int>();
foreach (var perm in permutations)
{
var num = perm[0] + perm[1] * 10 + perm[2] * 100 + perm[3] * 1000;
if (calc.IsPrime((ulong)num) && !numbers.Contains(num) && num>999 && num>=n)
numbers.Add(num);
}
numbers.Sort();
for (int i = 1; i < numbers.Count-1; i++)
{
for (int j = i+1; j < numbers.Count; j++)
{
if (numbers[j]-numbers[i]==numbers[i]-numbers[0])
Console.Write("{0}{1}{2}\n", numbers[0], numbers[i], numbers[j]);
}
}
}
}
public DelaysSelectationViewModel(List<GKDelay> delays)
{
Title = "Выбор задержек";
AddCommand = new RelayCommand<object>(OnAdd, CanAdd);
RemoveCommand = new RelayCommand<object>(OnRemove, CanRemove);
AddAllCommand = new RelayCommand(OnAddAll, CanAddAll);
RemoveAllCommand = new RelayCommand(OnRemoveAll, CanRemoveAll);
CreateNewCommand = new RelayCommand(OnCreateNew);
Delays = delays;
TargetDelays = new SortableObservableCollection<GKDelay>();
SourceDelays = new SortableObservableCollection<GKDelay>();
foreach (var delay in GKManager.DeviceConfiguration.Delays)
{
if (Delays.Contains(delay))
TargetDelays.Add(delay);
else
SourceDelays.Add(delay);
}
TargetDelays.Sort(x => x.No);
SourceDelays.Sort(x => x.No);
SelectedTargetDelay = TargetDelays.FirstOrDefault();
SelectedSourceDelay = SourceDelays.FirstOrDefault();
}
public ActionResult AddGroup(Web_UserGroup model)
{
ViewBag.ALLFunctions = new Web_Sys_FunctionBLL().GetAllFunctions(dbParm);
try
{
string t = Request["FunctionId"].ToString();//获取选中的分类ID格式为("1，2，3”)不包含括号。
List<Int32> idlist = new List<int>();
if (!string.IsNullOrEmpty(t))
{
if (t.Contains(","))
{
foreach (var each in t.Split(',').ToList())
{
idlist.Add(Convert.ToInt32(each));
}
}
else
{
idlist.Add(Convert.ToInt32(t));
}
}
IEnumerable<Web_Sys_Function> selectedFuncs = new Web_Sys_FunctionBLL().GetAllFunctions(dbParm).Where(p => idlist.Contains(p.ID));
if (model.Group_ID == 0) //New
{
model.Web_Sys_Functions = selectedFuncs.ToList();
//model.Web_Sys_Functions = new List<Web_Sys_Function>();
//selectedFuncs.ToList().ForEach(f => model.Web_Sys_Functions.Add(f));
groupBLL.AddNew(model, dbParm);
}
else //Edit
{
List<Web_Sys_Function> originalFuncs = groupBLL.Get(model.Group_ID, dbParm).Web_Sys_Functions;
model.Web_Sys_Functions = originalFuncs;
//要删除的function
var dlist = originalFuncs.Where(p => !selectedFuncs.Contains(p)).ToList();
//要添加的function
var alist = selectedFuncs.Where(p => !originalFuncs.Contains(p)).ToList();
foreach (var item in dlist)
{
model.Web_Sys_Functions.Remove(item);
}
foreach (var item in alist)
{
model.Web_Sys_Functions.Add(item);
}
groupBLL.Update(model, dbParm);
}
ViewBag.ALLFunctions = new Web_Sys_FunctionBLL().GetAllFunctions(dbParm);
return null;
//return View();
}
catch (Exception ex)
{
var y = ex.InnerException;
return View(model);
}
}
public Zone_Area GetArea(ushort PinX, ushort PinY, byte Realm, List<Zone_Area> Excepts=null)
{
foreach(Zone_Area Area in Areas)
{
if (Area.Realm == Realm && Area.IsOnArea(PinX,PinY))
if (Excepts == null || !Excepts.Contains(Area))
return Area;
}
return null;
}
public void UpdateIgnoredExtensionsFilter(List<string> _ignoredExtensions)
{
Debug.Assert(_ignoredExtensions != null);
ExtensionFilter.Set(item =>
{
var file = item as FileInfo;
Debug.Assert(file != null);
return !_ignoredExtensions.Contains(Path.GetExtension(file.Name));
});
}
static List<DateTime> GetFileDates(string folderPath)
{
List<DateTime> result = new List<DateTime>();
string[] files = Directory.GetFiles(folderPath,"*.requestData");
foreach (string file in files)
{
DateTime dt = FileUtils.FileNameToDate(file);
if (!result.Contains(dt))
result.Add(dt);
}
return result;
}
string CreateNewCaption(List<string> otherCaptions)
{
var defaultCaption = "Новый макет";
var counter = 1;
var newCaption = defaultCaption;
while (otherCaptions.Contains(newCaption))
{
newCaption = string.Format("{0}({1})", defaultCaption, counter);
counter++;
}
return newCaption;
}
private void btnImport_Click(object sender, EventArgs e)
{
//整体表格
var multilanFolder = ctlMultiLanFolder.SelectedPathOrFileName;
//整理出最大列表，防止文件之间出现单词表格不同
var uuiDs = new List<string>();
uuiDs.Clear();
if (!string.IsNullOrEmpty(multilanFolder))
{
//便利整个文件夹，获得语言字典
foreach (var filename in Directory.GetFiles(multilanFolder))
{
StringResource.InitLanguage(filename);
var singleDic = new Dictionary<string, string>();
foreach (var item in StringResource.StringDic)
{
if (!uuiDs.Contains(item.Key)) uuiDs.Add(item.Key);
singleDic.Add(item.Key, item.Value);
}
_multiLanguageDictionary.Add(StringResource.LanguageType, singleDic);
}
}
//将数据放入ListView视图
lstMultiLan.Clear();
//Header
lstMultiLan.Columns.Add("统一标示");
for (var i = 0; i < _multiLanguageDictionary.Keys.Count; i++)
{
lstMultiLan.Columns.Add(_multiLanguageDictionary.Keys.ElementAt(i));
}
//Details
for (var i = 0; i < uuiDs.Count; i++)
{
var item = new ListViewItem(uuiDs[i]);
for (var j = 0; j < _multiLanguageDictionary.Keys.Count; j++)
{
if (_multiLanguageDictionary[_multiLanguageDictionary.Keys.ElementAt(j)].ContainsKey(uuiDs[i]))
{
item.SubItems.Add(_multiLanguageDictionary[_multiLanguageDictionary.Keys.ElementAt(j)][uuiDs[i]]);
}
else
{
item.SubItems.Add("");
}
}
lstMultiLan.Items.Add(item);
}
Utility.ListViewColumnResize(lstMultiLan);
}
private List<String> GetEventList()
{
List<String> event_list=new List<string>();
//按行遍历EmbeddedSet表，list里面没有就加进去
DataTable dt= DAL.SQLHelper.ExecuteDt("select * from EmbeddedSet");
foreach (DataRow row in dt.Rows)
{
if (!event_list.Contains(row["Item1"].ToString()))
{
event_list.Add(row["Item1"].ToString());
}
}
return event_list;
}
//write events from here
static void Main(string[] args)
{
const string textMessageStream = "text-message";
var service = new EventStoreService(Config.IpAddress, Config.DefaultPort);
var people = new List<string> {"jim", "mike", "susie"};
//simulate already subscribed. This information would come from the actual message in the form of it not being the first
//phase transition or something else that tells us that this is not the first message related to an individuals
var alreadySubscribed = new List<string>();
var count = 0;
using (service)
{
while (true)
{
count++;
var person = people[count%3];
var model = BuildTextMessage(person);
var metadata = new Metadata { ClassVersion = 1 };
var subStream = $"{textMessageStream}-{person}";
if (alreadySubscribed.Contains(person) == false)
{
service.SubscribeToStream(subStream, (s, @event) =>
{
var metaData = service.GetStreamMetaData<Counter>(subStream);
var textMessage = JsonConvert.DeserializeObject<TextMessageSent>(Utility.BytesToString(@event.Event.Data));
Console.WriteLine($"Substream text message received for stream: {subStream}. Data {textMessage.Sender} - {textMessage.Message}");
Console.WriteLine($"Count is {metaData.Count}");
metaData.Count++;
service.SetMetaData(subStream, metaData);
});
alreadySubscribed.Add(person);
}
service.WriteToStreamAsync(textMessageStream, "messageSend", model, metadata);
service.WriteToStreamAsync(subStream, "messageSend", model, metadata);
Thread.Sleep(1000);
}
}
}
private void AddIgnoredExtension(object _params)
{
string extension = _params as string;
Debug.Assert(extension != null);
extension = extension.ToLowerInvariant();
var ignoredExtensions = new List<string>(Settings.Default.IgnoredExtensions);
if (!ignoredExtensions.Contains(extension))
{
ignoredExtensions.Insert(0, extension);
ClearInput(null);
}
Settings.Default.IgnoredExtensions = ignoredExtensions;
Settings.Default.Save();
}
public DoorsSelectationViewModel(List<GKDoor> doors, List<GKDoorType> doorsTypes = null)
{
Title = "Выбор точек доступа";
AddCommand = new RelayCommand<object>(OnAdd, CanAdd);
RemoveCommand = new RelayCommand<object>(OnRemove, CanRemove);
AddAllCommand = new RelayCommand(OnAddAll, CanAddAll);
RemoveAllCommand = new RelayCommand(OnRemoveAll, CanRemoveAll);
CreateNewCommand = new RelayCommand(OnCreateNew);
Doors = doors;
TargetDoors = new SortableObservableCollection<GKDoor>();
SourceDoors = new SortableObservableCollection<GKDoor>();
var allDoors = GKManager.DeviceConfiguration.Doors;
if (doorsTypes != null)
{
var filteredDoors = new List<GKDoor>();
foreach (var door in allDoors)
foreach (var doorType in doorsTypes)
{
if (door.DoorType == doorType)
{
filteredDoors.Add(door);
break;
}
}
allDoors = filteredDoors;
}
foreach (var door in allDoors)
{
if (Doors.Contains(door))
TargetDoors.Add(door);
else
SourceDoors.Add(door);
}
TargetDoors.Sort(x => x.No);
SourceDoors.Sort(x => x.No);
SelectedTargetDoor = TargetDoors.FirstOrDefault();
SelectedSourceDoor = SourceDoors.FirstOrDefault();
}
public static List<int> StringToList(string ids)
{
List<int> lst = new List<int>();
if (ids.Trim().Length > 0)
{
ArrayList ary = new ArrayList(ids.Split(new char[] { ',' }));
foreach (string temp in ary)
{
if (temp.Trim().Length > 0)
{
int id = StringToInt(temp);
if (id < 0)
{
id = -id;
}
if (!((id == 0) || lst.Contains(id)))
{
lst.Add(id);
}
}
}
}
return lst;
}
/// <summary>
/// 获取问题记录
/// </summary>
/// <param name="pager"></param>
/// <param name="tid"></param>
/// <param name="cids"></param>
/// <param name="layer"></param>
/// <param name="sort"></param>
/// <param name="order"></param>
/// <param name="user"></param>
/// <returns></returns>
public Pager GetReplyPaging(Pager pager, string cids, string sort = "", string order = "desc", string user = "")
{
IQueryable<Pts_Problems> query = db.Pts_Problems;
if (cids != "")
{
List<int> listids = new List<string>(cids.Split(',')).ConvertAll(i => int.Parse(i));
query = query.Where(m => listids.Contains(m.CategoryID));
}
switch (sort)
{
case "NewQuestion":
query = query.Where(m => m.IsStart == true);
break;
case "MyReplay":
query = query.Where(m => m.HandlingUser == user);
break;
case "SolvedQuestion":
query = query.Where(m => m.IsClosed == true);
break;
case "MySolvedQuestion":
query = query.Where(m => m.SolveUser == user);
break;
default:
break;
}
pager.Amount = query.Count();
if (order == "desc")
query = query.OrderByDescending(m => m.ProblemID);
else
query = query.OrderBy(m => m.ProblemID);
query = query.Skip(pager.PageSize * pager.PageNo).Take(pager.PageSize);
pager.Entity = query;
return pager;
}
static void AddInputOutputObject(List<XBase> objects, XBase newObject)
{
if (!objects.Contains(newObject))
objects.Add(newObject);
}
/// <summary>
/// 递归取得文件夹下文件
/// </summary>
/// <param name="dir"></param>
/// <param name="list"></param>
/// <param name="fileExtsions"></param>
public static void GetFiles(string dir, List<string> list, List<string> fileExtsions)
{
//添加文件
string[] files = Directory.GetFiles(dir);
if (fileExtsions.Count > 0)
{
foreach (string file in files)
{
string extension = Path.GetExtension(file);
if (extension != null && fileExtsions.Contains(extension))
{
list.Add(file);
}
}
}
else
{
list.AddRange(files);
}
//如果是目录，则递归
DirectoryInfo[] directories = new DirectoryInfo(dir).GetDirectories();
foreach (DirectoryInfo item in directories)
{
GetFiles(item.FullName, list, fileExtsions);
}
}
static void Main(string[] args)
{
var timeStr = DateTime.Now.Hour.ToString("D2") + DateTime.Now.Minute.ToString("D2");
var nodeParamsDeserialize = new ParametersSerializer<NodeParameters>();
var psoParamsDeserialize = new ParametersSerializer<PsoParameters>();
var nodeParams = nodeParamsDeserialize.Deserialize("nodeParams.xml");
var psoParams = psoParamsDeserialize.Deserialize("psoParams.xml");
MachineManager machineManager = new MachineManager(nodeParams.Ip, nodeParams.Ports.ToArray(), nodeParams.NrOfVCpu);
if (nodeParams.PeerAddress != null)
{
try
{
machineManager.Register(nodeParams.PeerAddress);
}
catch (Exception e)
{
Console.WriteLine("Unexpected error occured. Plase try to connect once again.");
return;
}
Console.WriteLine("Working...");
Console.WriteLine("Press ENTER to finish");
ConsoleKeyInfo pressed = new ConsoleKeyInfo();
while (pressed.Key != ConsoleKey.Enter)
{
pressed = Console.ReadKey();
};
}
else
{
if (args.Length < 3)
{
Console.WriteLine("CocoClusterApp <Dim1[,Dim2,Dim3...]> <FunctionsFrom> <FunctionsTo> <Budget>");
return;
}
var dims = args[0];
var functionsFrom = int.Parse(args[1]);
var functionsTo = int.Parse(args[2]);
var budgetMultiplier = int.Parse(args[3]);
var randomGenerator = RandomGenerator.GetInstance(RandomSeed);
CocoLibraryWrapper.cocoSetLogLevel("warning");
var functionsToOptimize = new List<string>();
for (var i = functionsFrom; i <= functionsTo; i++)
{
functionsToOptimize.Add(string.Format("f{0:D3}", i));
}
Console.WriteLine("Press any key on the keyboard when ready...");
Console.ReadKey();
Console.WriteLine("Running the example experiment... (might take time, be patient)");
try
{
/* Set some options for the observer. See documentation for other options. */
var observerOptions =
"result_folder: " +
String.Format("{0}P_{1}G", psoParams.ParticleIterationsToRestart,
psoParams.PsoIterationsToRestart)
+ " algorithm_name: PSO"
+ " algorithm_info: \"A simple Random search algorithm\"";
/* Initialize the suite and observer */
var suite = new Suite("bbob", "year: 2016", "dimensions: " + dims);
var observer = new Observer("bbob", observerOptions);
var benchmark = new Benchmark(suite, observer);
/* Iterate over all problems in the suite */
var evalLogger = new EvaluationsLogger();
PsoServiceLocator.Instance.Register<EvaluationsLogger>(evalLogger);
var fileLogger = new FileLogger("evals.csv");
fileLogger.Log("function_id,gpu_evals,cpu_evals,gpu/cpu");
int instanceCounter = 0;
while ((Problem = benchmark.getNextProblem()) != null)
{
instanceCounter = (instanceCounter + 1) % 15;
if(instanceCounter == 0)
{
evalLogger.RestartCounters();
}
var restarts = -1;
FitnessFunction function;
if (!functionsToOptimize.Contains(Problem.FunctionNumber)) continue;
var settings = SetupOptimizer(psoParams, out function);
var evaluations = (long) settings.FunctionParameters.Dimension * budgetMultiplier;
var evaluationsLeft = evaluations;
do
{
restarts++;
settings.Iterations =
(int)Math.Ceiling(evaluations / ((double)settings.Particles.Sum(pc => pc.Count)));
//var sendParams = new PsoParameters()
//{
// Iterations = psoParams.Iterations,
// TargetValueCondition = psoParams.TargetValueCondition,
// IterationsLimitCondition = psoParams.IterationsLimitCondition,
// PsoIterationsToRestart = psoParams.PsoIterationsToRestart,
// ParticleIterationsToRestart = psoParams.ParticleIterationsToRestart,
// Epsilon = psoParams.Epsilon,
// FunctionParameters = psoParams.FunctionParameters,
// ParticlesCount = 20,
// Particles = new ParticlesCount[1] { new ParticlesCount(PsoParticleType.Standard, 20)}
//};
machineManager.StartPsoAlgorithm(psoParams);
machineManager.GetResult();
var evalsDone = Problem.getEvaluations();
evaluationsLeft = evaluations - evalsDone;
} while (!Problem.isFinalTargetHit() && evaluationsLeft > 0 );
evalLogger.IncreaseCpuEvals((int)Problem.getEvaluations());
Console.WriteLine("{0} | {1} evaluations | {2} restarts | {3:e} BestEval ", Problem.Id, Problem.getEvaluations(), restarts, function.BestEvaluation.FitnessValue[0]);
if(instanceCounter == 14)
{
fileLogger.Log(String.Format("{0},{1},{2},{3}", Problem.Id.Substring(5,4), evalLogger._cpuEvaluations, evalLogger._gpuEvaluations, evalLogger.Ratio));
}
}
fileLogger.GenerateLog();
benchmark.finalizeBenchmark();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
Console.WriteLine("Done");
}
// Acttion, ������������ ������� �� ���������� �������
private void ShowChartAction_Execute(object sender, EventArgs e)
{
Plant CurrentPlant;
ReportPart CurrentPart;
DataRow ChartRow;
BookColumn ChartColumn;
GetCurrentCellInfo(out CurrentPlant, out CurrentPart, out ChartRow, out ChartColumn);
if (ChartColumn == null)
{
MessageBox.Show("���������� ������� ������� � ������� ��� ��������� ��������", "�������� ��������", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (ChartRow == null || CurrentPart == null)
{
MessageBox.Show("���������� ������� ������ � ��������� ��� ��������� ��������", "�������� ��������", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
string ModuleNorm = FM[CurrentPart.NormRow, ChartColumn.column1];
string ModuleName = "";
string CurrentFieldIndex = CurrentPart.FieldName(ChartColumn.column1).Split('*')[1];
object CurrentLowerNorm = ChartRow["LowerLimit*" + CurrentFieldIndex];
object CurrentUpperNorm = ChartRow["UpperLimit*" + CurrentFieldIndex];
List<Plant> PlantsList = new List<Plant>();
foreach (ReportPart part in Parts)
if (part.Data != null && part.Data.Rows.Count > 0)
{
Plant p = plants.FindPlant(Convert.ToInt32(part.Data[0, "plantid"]));
if (!PlantsList.Contains(p))
PlantsList.Add(p);
}
QueryResult[] ChartDatas = new QueryResult[PlantsList.Count];
DataRow ModuleRow;
int i = 0;
foreach (ReportPart part in Parts)
{
if (part.Data != null && part.Data.Rows.Count > 0)
{
string FieldName = part.FieldName(ChartColumn.column1);
if (FieldName != "")
{
string[] values = FieldName.Split('*');
int ColumnIndex = Functions.ConvertToInt32(values[1]);
ModuleRow = part.Columns.Rows[ColumnIndex];
ModuleName = ModuleRow["TextModule"].ToString();
if (ModuleRow["TestGroup"].ToString().Trim() != "")
ModuleName = ModuleRow["TestGroup"].ToString() + ", " + ModuleName;
string DateField = "qaodecisiontime";
string CertField = "batchno";
string DataField = "Result*" + ColumnIndex.ToString();
string MinField = "LowerLimit*" + ColumnIndex.ToString();
string MaxField = "UpperLimit*" + ColumnIndex.ToString();
// ���� ����� ���������, ��
/*if (ModuleNorm.ToLower() != ModuleRow["ModuleNorm"].ToString().ToLower())
continue;*/
if (CurrentLowerNorm.ToString().ToLower() != part.Data[0, MinField].ToString().ToLower()
|| CurrentUpperNorm.ToString().ToLower() != part.Data[0, MaxField].ToString().ToLower())
continue;
// ��������� ����� �������� �������
QueryResult dt = new QueryResult(part.Data.DefaultView.ToTable(false, DateField, CertField, DataField, MinField, MaxField));
// �������������� ��������
dt.Columns[DateField].ColumnName = "Date";
dt.Columns[CertField].ColumnName = "Passport";
dt.Columns[DataField].ColumnName = "Value";
dt.Columns[MinField].ColumnName = "Min";
dt.Columns[MaxField].ColumnName = "Max";
// ���������� ����� ��������
dt.AddColumn("PlantName", typeof(string), plants.FindPlant(Convert.ToInt32(part.Data[0, "plantid"])).ShortPlantName);
dt.AddColumn("Module", typeof(string), ModuleName);
dt.AddColumn("Norm", typeof(string), ModuleRow["ModuleNorm"]);
if (Functions.IsNumber(FM[part.RowAvg, ChartColumn.column1]))
dt.AddColumn("Average", typeof(double), FM[part.RowAvg, ChartColumn.column1]);
i = PlantsList.IndexOf(plants.FindPlant(Convert.ToInt32(part.Data[0, "plantid"])));
if (ChartDatas[i] == null)
ChartDatas[i] = new QueryResult(dt);
else
{
// ���� � ������ ������ ���� �������� � ����������� �������, �� �� ����� ����������
ChartDatas[i].Merge(dt);
// �������� ����������������� �������� ����� ����������� ������
if (ChartDatas[i].Columns.Contains("Average"))
{
object newavg = ChartDatas[i].Compute("avg(Average)", "");
foreach (DataRow row in ChartDatas[i].Rows)
row["Average"] = newavg;
}
}
}
}
if (ChartDatas[i] != null) // ��������� ������ ����� ������������ (����� ����������, ���� ���� ����������� ������ ���������)
{
DataView dv = ChartDatas[i].DefaultView;
dv.Sort = "Date, Passport";
ChartDatas[i] = new QueryResult(dv.ToTable());
}
}
//Array.Resize<QueryResult>(ref ChartDatas, 5);
ChartForm form = new ChartForm();
form.Text = string.Format("{0}. {1}, {2}", (ProductCombo.SelectedItem as DataRowView)["Description"], ModuleName, ModuleNorm);
form.TitleLabel.Text = form.Text;
form.Initialize(ChartDatas);
form.WindowState = FormWindowState.Maximized;
form.Show();
}
public void Init(Usr u)
{
AllMusicTypes = null;
SelectedMusicTypes = null;
GenericMusicTypes = null;
SelectedPlaces = null;
MusicQ = null;
PlaceQ = null;
#region Populate MusicQ and MusicTypes
if (u.FavouriteMusicTypeK == 0 && u.MusicTypesFavouriteCount == 0)
{
MusicQ = new Q(true);
}
else
{
List<int> musicTypesK = new List<int>();
#region Add MusicTypes
if (u.MusicTypesFavouriteCount > 0)
{
foreach (MusicType mt in u.MusicTypesFavourite)
{
if (!musicTypesK.Contains(mt.K))
{
musicTypesK.Add(mt.K);
AllMusicTypes.Add(mt.Order, mt);
SelectedMusicTypes.Add(mt.Order, mt);
AddMusicTypeChildren(mt, ref musicTypesK);
#region Add the parent
if (u.UpdateSendGenericMusic && mt.ParentK > 1 && !musicTypesK.Contains(mt.ParentK))
{
musicTypesK.Add(mt.ParentK);
AllMusicTypes.Add(mt.Parent.Order, mt.Parent);
GenericMusicTypes.Add(mt.Parent.Order, mt.Parent);
}
#endregion
}
}
}
else
{
if (u.FavouriteMusicTypeK != 0)
{
musicTypesK.Add(u.FavouriteMusicTypeK);
AllMusicTypes.Add(u.FavouriteMusicType.Order, u.FavouriteMusicType);
SelectedMusicTypes.Add(u.FavouriteMusicType.Order, u.FavouriteMusicType);
AddMusicTypeChildren(u.FavouriteMusicType, ref musicTypesK);
}
}
if (u.UpdateSendGenericMusic && !musicTypesK.Contains(1))
{
musicTypesK.Add(1);
MusicType mtAllMusic = new MusicType(1);
AllMusicTypes.Add(mtAllMusic.Order, mtAllMusic);
GenericMusicTypes.Add(mtAllMusic.Order, mtAllMusic);
}
#endregion
musicTypesK.Sort();
MusicQ = new Or(musicTypesK.ConvertAll<Q>(mtk => new Q(EventMusicType.Columns.MusicTypeK, mtk)).ToArray());
}
#endregion
#region Populate PlaceQ and SelectedPlaces
List<int> placesK = new List<int>();
if (u.HomePlaceK > 0)
{
placesK.Add(u.HomePlaceK);
SelectedPlaces.Add(u.Home.Name, u.Home);
}
foreach (Place p in u.PlacesVisit(null, 0))
{
if (!placesK.Contains(p.K))
{
placesK.Add(p.K);
SelectedPlaces.Add(p.Name, p);
}
}
if (placesK.Count > 0)
{
placesK.Sort();
PlaceQ = new Or(placesK.ConvertAll<Q>(pk => new Q(Venue.Columns.PlaceK, pk)).ToArray());
}
else
{
PlaceQ = new Q(false);
}
#endregion
}
private void RemoveIgnoredExtensions(object _params)
{
List<string> extensions = null;
string extension = _params as string;
if (extension != null)
{
extensions = new List<string> { extension };
}
else
{
IList items = (IList)_params;
extensions = items.Cast<string>().ToList();
}
Debug.Assert(extensions != null);
var ignoredExtensions = new List<string>(Settings.Default.IgnoredExtensions);
foreach (var ext in extensions)
{
extension = ext.ToLowerInvariant();
Debug.Assert(ignoredExtensions.Contains(extension));
ignoredExtensions.Remove(extension);
}
Settings.Default.IgnoredExtensions = ignoredExtensions;
Settings.Default.Save();
}
static void AddMusicTypeChildren(MusicType mt, ref List<int> musicTypes)
{
if (mt.Children.Count > 0)
{
foreach (MusicType mtChild in mt.Children)
{
if (!musicTypes.Contains(mtChild.K))
{
musicTypes.Add(mtChild.K);
}
if (mtChild.ParentK == 1)
{
AddMusicTypeChildren(mtChild, ref musicTypes);
}
}
}
}
private void FilterExtensions(List<string> _extensions)
{
Debug.Assert(_extensions != null);
ClearFilterExtensions();
ExtensionFilter = item =>
{
FileInfo fileInfo = item as FileInfo;
if (fileInfo == null)
{
return false;
}
bool searchMatched = !_extensions.Contains(fileInfo.Extension);
return searchMatched;
};
GroupFilter.AddFilter(ExtensionFilter);
}
private void AddRow(EmployeeAccessDataSet ds, EmployeeInfo employee, SKDCard card, CardDoor door, AccessTemplate template, Dictionary<Guid, Tuple<Tuple<GKSKDZone, string>, Tuple<GKSKDZone, string>>> zoneMap, List<Guid> addedZones)
{
if (!zoneMap.ContainsKey(door.DoorUID))
return;
var zones = zoneMap[door.DoorUID];
var dataRow = ds.Data.NewDataRow();
dataRow.Type = card.GKCardType.ToDescription();
dataRow.Number = card.Number.ToString();
if (employee != null)
{
dataRow.Employee = employee.Name;
dataRow.Organisation = employee.Organisation;
dataRow.Department = employee.Department;
dataRow.Position = employee.Position;
}
if (template != null)
dataRow.Template = template.Name;
if (zones.Item1 != null && !addedZones.Contains(zones.Item1.Item1.UID))
{
var row1 = ds.Data.NewDataRow();
row1.ItemArray = dataRow.ItemArray;
row1.Zone = zones.Item1.Item2;
row1.No = zones.Item1.Item1.No;
ds.Data.AddDataRow(row1);
addedZones.Add(zones.Item1.Item1.UID);
}
if (zones.Item2 != null && !addedZones.Contains(zones.Item2.Item1.UID))
{
var row2 = ds.Data.NewDataRow();
row2.ItemArray = dataRow.ItemArray;
row2.Zone = zones.Item2.Item2;
row2.No = zones.Item2.Item1.No;
ds.Data.AddDataRow(row2);
addedZones.Add(zones.Item2.Item1.UID);
}
}
