/// <summary>
/// 获取匹配的数据集合
/// </summary>
/// <param name="key">关键字</param>
/// <param name="isValue">数据匹配器,禁止锁操作</param>
/// <returns>数据集合</returns>
public valueType[] GetFindArrayNoOrderLock(keyType key, func <valueType, bool> isValue)
{
group values;
int version = keyVersion;
if (groups.TryGetValue(key, out values) && values.Key.Equals(key))
{
Monitor.Enter(cache.SqlTool.Lock);
try
{
return(values.List.GetFindArray(isValue));
}
finally { Monitor.Exit(cache.SqlTool.Lock); }
}
else if (version != keyVersion)
{
Monitor.Enter(cache.SqlTool.Lock);
try
{
if (groups.TryGetValue(key, out values))
{
return(values.List.GetFindArray(isValue));
}
}
finally { Monitor.Exit(cache.SqlTool.Lock); }
}
return(nullValue <valueType> .Array);
}
/// <summary>
/// 数组范围排序
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <param name="values">待排序数组</param>
/// <param name="startIndex">起始位置</param>
/// <param name="count">排序范围数据数量</param>
/// <param name="getKey">排序键值获取器</param>
/// <param name="skipCount">跳过数据数量</param>
/// <param name="getCount">排序数据数量</param>
/// <param name="fixedIndex">索引位置</param>
/// <returns>排序后的数组</returns>
private unsafe static valueType[] getRangeSort/*Compare[0]*//*Compare[0]*/ <valueType>
(valueType[] values, int startIndex, int count, func <valueType, /*Type[0]*/ ulong /*Type[0]*/> getKey, int skipCount, int getCount
, /*Type[2]*/ ulongSortIndex /*Type[2]*/ *fixedIndex)
{
/*Type[2]*/
ulongSortIndex /*Type[2]*/ *writeIndex = fixedIndex;
for (int index = startIndex, endIndex = startIndex + count; index != endIndex; ++index)
{
*writeIndex++ = new /*Type[2]*/ ulongSortIndex /*Type[2]*/ {
Value = getKey(values[index]), Index = index
};
}
new /*Type[3]*/ ulongRangeIndexSorter/*Type[3]*//*Compare[0]*//*Compare[0]*/
{
SkipCount = fixedIndex + skipCount,
GetEndIndex = fixedIndex + skipCount + getCount - 1
}.Sort(fixedIndex, fixedIndex + count - 1);
valueType[] newValues = new valueType[getCount];
writeIndex = fixedIndex + skipCount;
for (int index = 0; index != newValues.Length; ++index)
{
newValues[index] = values[(*writeIndex++).Index];
}
return(newValues);
}
/// <summary>
/// 排序去除Top N
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <param name="values">待排序数组</param>
/// <param name="getKey">排序键值获取器</param>
/// <param name="count">排序数据数量</param>
/// <returns>排序后的数据</returns>
private unsafe static valueType[] getRemoveTop/*Compare[0]*//*Compare[0]*/ <valueType>
(valueType[] values, func <valueType, /*Type[0]*/ ulong /*Type[0]*/> getKey, int count)
{
valueType[] newValues = new valueType[count];
count = values.Length - count;
uint sqrtMod;
int length = Math.Min(Math.Max(count << 2, count + (int)number.sqrt((uint)values.Length, out sqrtMod)), values.Length);
if (length > (config.pub.Default.StreamBufferLength >> 4))
{
/*Type[2]*/
ulongSortIndex /*Type[2]*/[] removeValues = new /*Type[2]*/ ulongSortIndex /*Type[2]*/[length];
fixed(/*Type[2]*/ ulongSortIndex /*Type[2]*/ *removeFixed = removeValues)
{
removeTop/*Compare[0]*//*Compare[0]*/ (values, getKey, count, newValues, length, removeFixed);
}
}
else
{
/*Type[2]*/
ulongSortIndex /*Type[2]*/ *removeFixed = stackalloc /*Type[2]*/ ulongSortIndex /*Type[2]*/[length];
removeTop/*Compare[0]*//*Compare[0]*/ (values, getKey, count, newValues, length, removeFixed);
}
return(newValues);
}
/// <summary>
/// 查找第一个匹配的数据
/// </summary>
/// <param name="key">关键字</param>
/// <param name="isValue">数据匹配器,禁止锁操作</param>
/// <returns>第一个匹配的数据,失败返回null</returns>
public valueType FirstOrDefaultLock(keyType key, func <valueType, bool> isValue)
{
group values;
int version = keyVersion;
if (groups.TryGetValue(key, out values) && values.Key.Equals(key))
{
Monitor.Enter(cache.SqlTool.Lock);
try
{
return(values.List.FirstOrDefault(isValue));
}
finally { Monitor.Exit(cache.SqlTool.Lock); }
}
else if (version != keyVersion)
{
Monitor.Enter(cache.SqlTool.Lock);
try
{
if (groups.TryGetValue(key, out values))
{
return(values.List.FirstOrDefault(isValue));
}
}
finally { Monitor.Exit(cache.SqlTool.Lock); }
}
return(null);
}
/// <summary>
/// 查找符合条件的记录集合
/// </summary>
/// <param name="values">值集合</param>
/// <param name="isValue">判断记录是否符合条件的委托</param>
/// <returns>符合条件的记录集合</returns>
public unsafe static list </*Type[0]*/ ulong /*Type[0]*/> getFind
(this System.Collections.ICollection values, func </*Type[0]*/ ulong /*Type[0]*/, bool> isValue)
{
if (values != null)
{
if (isValue == null)
{
log.Default.Throw(log.exceptionType.Null);
}
/*Type[0]*/
ulong /*Type[0]*/[] newValues = new /*Type[0]*/ ulong /*Type[0]*/[values.Count];
fixed(/*Type[0]*/ ulong /*Type[0]*/ *newValueFixed = newValues)
{
/*Type[0]*/
ulong /*Type[0]*/ *write = newValueFixed;
foreach (/*Type[0]*/ ulong /*Type[0]*/ value in values)
{
if (isValue(value))
{
*write++ = value;
}
}
return(new list </*Type[0]*/ ulong /*Type[0]*/>(newValues, 0, (int)(write - newValueFixed), true));
}
}
return(null);
}
public Object[] Exec(func f, output output, Object[] p_j, int nth)
{
_f = f;
_output = output;
_nth = nth;
_job = new SJobQueue();
_job.p_j = p_j;
_job.nj = p_j.Length;
_job.submitted_j = new bool[_job.nj];
_job.completed_j = new bool[_job.nj];
_job.outputted_j = new bool[_job.nj];
_job.th_j = new int[_job.nj];
_job.ret_j = new Object[_job.nj];
for (int j = 0; j < _job.nj; j++) _job.submitted_j[j] = false;
for (int j = 0; j < _job.nj; j++) _job.completed_j[j] = false;
for (int j = 0; j < _job.nj; j++) _job.outputted_j[j] = false;
System.Threading.Thread[] thread_th = new System.Threading.Thread[nth];
for (int th = 0; th < nth; th++)
{
thread_th[th] = new System.Threading.Thread(Iterate);
thread_th[th].Name = "CJobQueue Worker Thread " + th;
thread_th[th].Start();
System.Threading.Thread.Sleep(10);
}
Output();
for (int th = 0; th < nth; th++)
{
thread_th[th].Join();
}
return _job.ret_j;
}
private void BtnSearch_Click(object sender, EventArgs e)
{
BtnSearch.Enabled = false;
try
{
Search();
appl.StatusBar("開始載入EXCEL檔案...", MessageType.None);
//載入DGV
string strOrderCmd = " order by " + SOColName;//getOrderCmd();
func ff = new func();
oDT = loadGridFromExcel(s, strOrderCmd);
GV.DataSource = oDT;
appl.StatusBar("EXCEL載入完成!!", MessageType.Success);
if (Chk())
{
BtnOK.Enabled = true;
}
else
{
BtnOK.Enabled = false;
}
appl.StatusBar("檢查完成!!", MessageType.None);
}
catch (Exception ex)
{
appl.SetSystemLog(ex.ToString());
}
BtnSearch.Enabled = true;
}
public static double Solve(double left, double right, double epsilon, func func)
{
int iteration = 0;
double c = 0;
while (true)
{
double cPrev = c;
Tools.PrintIteration(++iteration);
Console.WriteLine($"a: {left}");
Console.WriteLine($"b: {right}");
c = left - (func(left) * (right - left)) / (func(right) - func(left));
Console.WriteLine($"c: {c}");
Console.WriteLine("Ck-1: {0}", cPrev);
if (func(right) * func(c) < 0)
{
left = c;
}
else
{
right = c;
}
if (Tools.SimpleStopCriteria(c, cPrev, epsilon))
{
return(c);
}
}
}
/// <summary>
/// 根据集合内容返回数组
/// </summary>
/// <typeparam name="valueType">枚举值类型</typeparam>
/// <param name="values">值集合</param>
/// <param name="getValue">获取数组值的委托</param>
/// <returns>数组</returns>
public unsafe static /*Type[0]*/ ulong /*Type[0]*/[] getArray <valueType>
(this System.Collections.Generic.ICollection <valueType> values, func <valueType, /*Type[0]*/ ulong /*Type[0]*/> getValue)
{
if (values.count() != 0)
{
if (getValue == null)
{
log.Default.Throw(log.exceptionType.Null);
}
/*Type[0]*/
ulong /*Type[0]*/[] newValues = new /*Type[0]*/ ulong /*Type[0]*/[values.Count];
fixed(/*Type[0]*/ ulong /*Type[0]*/ *newValueFixed = newValues)
{
/*Type[0]*/
ulong /*Type[0]*/ *write = newValueFixed;
foreach (valueType value in values)
{
*write++ = getValue(value);
}
}
return(newValues);
}
return(nullValue </*Type[0]*/ ulong /*Type[0]*/> .Array);
}
/// <summary>
/// Constructor which inits the TranslationFunction and RotationFunction attributes.
/// </summary>
public Sensor()
{
//m_Rotation.Sensor = this;
//m_Translation.Sensor = this;
m_TranslationFunction = set_Function(functions.none);
m_RotationFunction = set_Function(functions.none);
}
public ActionResult loginAdmin(string acc, string pass)
{
if (func.LoginAdmin(acc, pass))
{
func f = new func();
Customer cs = func.GetCustomer(acc);
if (cs.idUser == 2)
{
return(Content("AdminLogin"));
}
if (cs != null)
{
Session["customers"] = cs;
if (cs.idCusAuthe == 1)
{
return(Content("AdminLogin"));
}
else
{
return(Content("RegisterForm"));
}
}
else
{
return(Content("RegisterForm"));
}
}
else
{
return(Content("RegisterForm"));
}
}
/// <summary>
/// 分组求和
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="keyType">分组键值类型</typeparam>
/// <param name="values">数据集合</param>
/// <param name="getKey">键值获取器</param>
/// <param name="getValue">数据获取器</param>
/// <returns>分组求和</returns>
public static System.Collections.Generic.Dictionary <keyType, /*Type[0]*/ ulong /*Type[0]*/> groupSum <valueType, keyType>
(this System.Collections.Generic.IEnumerable <valueType> values, func <valueType, keyType> getKey
, func <valueType, /*Type[0]*/ ulong /*Type[0]*/> getValue)
{
if (values != null)
{
if (getKey == null || getValue == null)
{
log.Default.Throw(log.exceptionType.Null);
}
/*Type[0]*/
ulong /*Type[0]*/ sum;
System.Collections.Generic.Dictionary <keyType, /*Type[0]*/ ulong /*Type[0]*/> sums
= new System.Collections.Generic.Dictionary <keyType, /*Type[0]*/ ulong /*Type[0]*/>();
foreach (valueType value in values)
{
keyType key = getKey(value);
if (sums.TryGetValue(key, out sum))
{
sums[key] = (/*Type[0]*/ ulong /*Type[0]*/)(sum + getValue(value));
}
else
{
sums.Add(key, getValue(value));
}
}
return(sums);
}
return(null);
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertInSet(sql.expression.converter converter, Expression expression)
{
charStream stream = converter.Stream;
BinaryExpression binaryExpression = (BinaryExpression)expression;
Expression left = binaryExpression.Left;
converters[(int)left.NodeType](converter, left);
stream.Write(" In(");
func <object, string> toString = null;
int index = -1;
foreach (object value in (IEnumerable)((ConstantExpression)binaryExpression.Right).Value)
{
if (++index == 0)
{
toString = constantConverter.Default[value.GetType()];
}
else
{
stream.Write(',');
}
stream.Write(toString != null ? toString(value) : constantConverter.convertConstantStringMssql(value.ToString()));
}
stream.Write(')');
}
// Численно вычисляет матрицу Гессе(матрицу двойных производных)
public static decimal[,] ComputeHessian(func f, List <decimal> x, decimal step)
{
var matrix = new decimal[x.Count, x.Count];
var varCount = x.Count;
var fPlus = new decimal[varCount];
var args = new decimal[varCount];
x.CopyTo(args);
var curFValue = f(args); //значение функции в текущей точке
for (int i = 0; i < varCount; i++)
{
x.CopyTo(args);
args[i] += step;
fPlus[i] = f(args);
}
for (int i = 0; i < varCount; i++)
{
for (int j = 0; j < varCount; j++)
{
x.CopyTo(args);
args[i] += step;
args[j] += step;
decimal value = f(args);
matrix[i, j] = (value - fPlus[i] - fPlus[j] + curFValue) / (step * step);
}
}
return(matrix);
}
public static bool SpellImmuneTargetAll(func f)
{
if (Game.GetOpponentMinions().Any(i => !i.CantTarget && !i.Stealth && f(i)))
{
return(true);
}
else
{
if (!Game.Opponent.Stealth && f(Game.Opponent.Hero))
{
return(true);
}
else
{
if (Game.GetUserMinions().Any(i => !i.CantTarget && f(i)))
{
return(true);
}
else
{
if (f(Game.User.Hero))
{
return(true);
}
else
{
return(false);
}
}
}
}
}
public static void Init(int width, int height, func init, func mainLoop, func final, bool isShowInfo = true)
{
ChangeWindowMode(TRUE);
SetGraphMode(width, height, 32);
DxLib_Init();
SetDrawScreen(DX_SCREEN_BACK);
init();
MATRIX matrix = MGetIdent();
while (ScreenFlip() == 0 && ClearDrawScreen() == 0 && ProcessMessage() == 0 && CheckHitKey(KEY_INPUT_ESCAPE) == 0)
{
Input.Update();
Time.Update();
TaskManager.Update();
Obj.UpdateAll();
mainLoop();
if (isShowInfo)
{
SetTransformTo2D(out matrix);
DrawString(0, 0, string.Format("FPS:{0:f1},オブジェ:{1},タスク:{2}", Time.GetCurrentFps(), Obj.Count, TaskManager.Count), GetColor(255, 255, 255));
}
}
final();
DxLib_End();
}
public static same_func bind <P1, T1>(func <P1> handler, T1 p1)
{
return(delegate(object[] args)
{
handler((P1)(functional._ == (object)p1 ? args[0] : p1));
});
}
public IntersectionPeriod(DateTime start, DateTime end, func function, DataPoint d1, DataPoint d2)
{
//find start and end of the overlap
this.start = start;
this.end = end;
//calculate new value
switch (function)
{
case func.plus:
{
value = d1.getValue() + d2.getValue();
break;
}
case func.minus:
{
value = d1.getValue() - d2.getValue();
break;
}
case func.mult:
{
value = d1.getValue() * d2.getValue();
break;
}
case func.div:
{
value = d1.getValue() / d2.getValue();
break;
}
}
}
private void RunStart()
{
done = false;
if (caves)
{
surfaceFunc = TerrainCave;
}
else
{
surfaceFunc = TerrainPlane;
}
List <Thread> threadsList = new List <Thread> ();
Vector2 [] Keys = new Vector2[generated.Count];;
generated.Keys.CopyTo(Keys, 0);
foreach (Vector2 pos in Keys)
{
bool check = false;
lock (lock_obj){
check = (bool)generated[pos];
}
if (!check)
{
Thread t = new Thread(Generate);
threadsList.Add(t);
t.Start(pos);
}
}
//foreach (Thread t in threadsList) t.Join ();
}
public static void getConformation(func function)
{
ConformationWindow.function = function;
Kernel.disalble();
win.enabled = true;
machine.goTo(ConformationStateMachine.confirm.yes);
}
/// <summary>
/// 获取最小值记录
/// </summary>
/// <typeparam name="valueType">值类型</typeparam>
/// <param name="values">值集合</param>
/// <param name="getKey">获取排序键的委托</param>
/// <param name="key">最小值</param>
/// <returns>是否存在最小值</returns>
public static bool minKey <valueType>
(this System.Collections.Generic.ICollection <valueType> values, func <valueType, /*Type[0]*/ ulong /*Type[0]*/> getKey
, out /*Type[0]*/ ulong /*Type[0]*/ key)
{
if (values.count() != 0)
{
if (getKey == null)
{
log.Default.Throw(log.exceptionType.Null);
}
valueType value = default(valueType);
int count = -1;
key = /*Type[0]*/ ulong /*Type[0]*/.MaxValue;
foreach (valueType nextValue in values)
{
if (++count == 0)
{
key = getKey(value = nextValue);
}
else
{
/*Type[0]*/
ulong /*Type[0]*/ nextKey = getKey(nextValue);
if (nextKey < key)
{
value = nextValue;
key = nextKey;
}
}
}
return(true);
}
key = default(/*Type[0]*/ ulong /*Type[0]*/);
return(false);
}
public Trie(Alphabet alphabet)
{
_charToIndex = alphabet._charToIndex;
_indexToChar = alphabet._indexToChar;
R = alphabet.R;
root = new TrieNode();
}
public static double integrate(func f, System.Collections.Generic.IReadOnlyList <double> init_ticks, double eps1)
{
var points = new System.Collections.Generic.Stack <Point>();
var areas = new System.Collections.Generic.List <double>();
foreach (var x in init_ticks)
{
points.Push(new Point(x, f(x)));
}
var full_width = init_ticks.Last() - init_ticks.First();
Point right;
double eps = eps1 * 4.0 / full_width;
while (points.Count > 1)
{
//Console.WriteLine(points.Count);
right = points.Pop();
var left = points.Peek();
var mid = Integration.midpoint(ref left, ref right, f);
if (Math.Abs(left.f + right.f - mid.f * 2.0) <= eps)
{
areas.Add((left.f + right.f + mid.f * 2.0) * (right.x - left.x) / 4.0);
}
else
{
points.Push(mid);
points.Push(right);
}
}
areas.Sort(delegate(double x, double y){
return(Math.Abs(x).CompareTo(Math.Abs(y)));
});
return(areas.Sum());
}
public void Add(RelationType relationType, bool usePercent)
{
if (relationType == RelationType.Size)
{
Add(RelationType.Width, usePercent);
Add(RelationType.Height, usePercent);
return;
}
func f = SIDE_FUNCTIONS[(int)relationType];
foreach (RelationDef def in _defs)
{
if (def.setFunction == f)
{
return;
}
}
RelationDef info = new RelationDef();
info.affectBySelfSizeChanged = relationType >= RelationType.Center_Center && relationType <= RelationType.Right_Right ||
relationType >= RelationType.Middle_Middle && relationType <= RelationType.Bottom_Bottom;
info.percent = usePercent;
info.setFunction = f;
_defs.Add(info);
}
private void package_combo()
{
if (package.Items.Count == 0)
{
try
{
string querry = "Select Description,Price from Container_Package ";
SqlCommand cmd = new SqlCommand(querry);
SqlConnection con = new func().con();
cmd.Connection = con;
try
{
con.Open();
SqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
package.Items.Add(rdr[0].ToString());
}
}
catch (Exception c)
{
}
finally
{
con.Close();
}
}
catch (Exception)
{
}
}
}
/// <summary>
/// 获取匹配数据集合
/// </summary>
/// <param name="key">关键字</param>
/// <param name="isValue">数据匹配器,禁止锁操作</param>
/// <returns>匹配数据集合</returns>
public list <valueType> GetFindLock(keyType key, func <valueType, bool> isValue)
{
keyValue <keyType, list <valueType> > list;
int version = keyVersion;
if (groups.TryGetValue(key, out list) && list.Key.Equals(key))
{
Monitor.Enter(cache.SqlTool.Lock);
try
{
return(list.Value.GetFind(isValue));
}
finally { Monitor.Exit(cache.SqlTool.Lock); }
}
else if (version != keyVersion)
{
Monitor.Enter(cache.SqlTool.Lock);
try
{
if (groups.TryGetValue(key, out list))
{
return(list.Value.GetFind(isValue));
}
}
finally { Monitor.Exit(cache.SqlTool.Lock); }
}
return(null);
}
static public double[] descent_method(func f, double[] vars, double eps, int max_steps_count)
{
double B = f(vars), A = 0;
double delta = 0.0;
for (int i = 0; i < max_steps_count; i++)
{
A = B;
for (int var_index = 0; var_index < vars.Length; var_index++)
{
vars[var_index] = golden_section(f, vars, var_index, eps, -0.75, 0.75, max_steps_count);
}
B = f(vars);
delta = Math.Abs(A - B);
if (delta <= eps)
{
break;
}
}
return(vars);
}
public static double newtonDecent(func func, dfunc dfunc)
{
double x0 = 0;
double x1 = x0 + 1;
double step = 0.0002;
int i = 0;
bool first = true;
while (Math.Abs(func.Invoke(x1) - func.Invoke(x0)) > 0.00000001)
{
if (!first)
{
x0 = x1;
first = false;
}
x1 = x0 + step * dfunc.Invoke(x1);
if (func.Invoke(x1) < func.Invoke(x0))
{
step /= 2;
}
else
{
step *= 2;
}
i++;
}
return(func.Invoke(x1));
}
/// <summary>
/// 数组范围排序
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <param name="values">待排序数组</param>
/// <param name="startIndex">起始位置</param>
/// <param name="count">排序范围数据数量</param>
/// <param name="getKey">排序键值获取器</param>
/// <param name="skipCount">跳过数据数量</param>
/// <param name="getCount">排序数据数量</param>
/// <returns>排序后的数组</returns>
public unsafe static valueType[] GetRangeSort/*Compare[0]*//*Compare[0]*/ <valueType>
(valueType[] values, int startIndex, int count, func <valueType, /*Type[0]*/ ulong /*Type[0]*/> getKey, int skipCount, int getCount)
{
array.range range = new array.range(values.length(), startIndex, count);
if ((count = range.GetCount) != 0)
{
array.range getRange = new array.range(count, skipCount, getCount);
if ((getCount = getRange.GetCount) != 0)
{
if (getKey == null)
{
log.Default.Throw(log.exceptionType.Null);
}
if (values.Length > (config.pub.Default.StreamBufferLength >> 4))
{
/*Type[2]*/
ulongSortIndex /*Type[2]*/[] indexs = new /*Type[2]*/ ulongSortIndex /*Type[2]*/[count];
fixed(/*Type[2]*/ ulongSortIndex /*Type[2]*/ *fixedIndex = indexs)
{
return(getRangeSort/*Compare[0]*//*Compare[0]*/
(values, range.SkipCount, count, getKey, getRange.SkipCount, getCount, fixedIndex));
}
}
else
{
/*Type[2]*/
ulongSortIndex /*Type[2]*/ *fixedIndex = stackalloc /*Type[2]*/ ulongSortIndex /*Type[2]*/[count];
return(getRangeSort/*Compare[0]*//*Compare[0]*/
(values, range.SkipCount, count, getKey, getRange.SkipCount, getCount, fixedIndex));
}
}
}
return(nullValue <valueType> .Array);
}
/// <summary>
/// 获取匹配分页集合
/// </summary>
/// <param name="pageSize">分页长度</param>
/// <param name="currentPage">当前页号</param>
/// <param name="isValue">数据匹配器</param>
/// <param name="count">匹配数据总数</param>
/// <returns>匹配分页集合</returns>
internal list <valueType> GetArrayPage(int pageSize, int currentPage, func <valueType, bool> isValue, out int count)
{
int valueCount = 0;
array.page page = new array.page(Array.Length, pageSize, currentPage);
int currentPageSize = page.CurrentPageSize;
list <valueType> .unsafer values = new list <valueType>(page.CurrentPageSize).Unsafer;
int skipCount = page.SkipCount;
currentPageSize += skipCount;
foreach (valueType value in Array)
{
if (isValue(value))
{
if (valueCount >= skipCount && valueCount < currentPageSize)
{
values.Add(value);
}
++valueCount;
}
}
count = valueCount;
return(values.List);
}
/// <summary>
/// 数组排序
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <param name="values">待排序数组</param>
/// <param name="getKey">排序键值获取器</param>
/// <param name="startIndex">起始位置</param>
/// <param name="count">排序数据数量</param>
/// <param name="fixedIndex">索引位置</param>
/// <returns>排序后的数组</returns>
private unsafe static valueType[] getSort/*Compare[0]*//*Compare[0]*/ <valueType>
(valueType[] values, func <valueType, /*Type[0]*/ ulong /*Type[0]*/> getKey, int startIndex, int count
, /*Type[1]*/ ulongSortIndex /*Type[1]*/ *fixedIndex)
{
/*Type[1]*/
ulongSortIndex /*Type[1]*/ *writeIndex = fixedIndex;
if (count > 1)
{
if (getKey == null)
{
log.Default.Throw(log.exceptionType.Null);
}
for (int index = startIndex, endIndex = startIndex + count; index != endIndex; ++index)
{
*writeIndex++ = new /*Type[1]*/ ulongSortIndex /*Type[1]*/ {
Value = getKey(values[index]), Index = index
};
}
sort/*Compare[0]*//*Compare[0]*/ (writeIndex = fixedIndex, fixedIndex + count - 1);
}
else
{
*fixedIndex = new /*Type[1]*/ ulongSortIndex /*Type[1]*/ {
Index = startIndex
}
};
valueType[] newValues = new valueType[count];
for (int index = 0; index != newValues.Length; ++index)
{
newValues[index] = values[(*writeIndex++).Index];
}
return(newValues);
}
}
public bool Run(out string output)
{
if (IsFunction)
{
if (paras.Count < fe.numberparasmin)
{
output = "Too few parameters";
}
else
{
System.Reflection.MethodInfo mi = GetType().GetMethod(fe.fname, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
func fptr = (func)Delegate.CreateDelegate(typeof(func), this, mi); // need a delegate which is attached to this instance..
bool res = fptr(out output);
return(res);
}
}
else if (paras.Count != 1)
{
output = "Missing variable name between brackets";
}
else if (vars.Exists(paras[0].Value))
{
output = vars[paras[0].Value];
return(true);
}
else
{
output = "Variable '" + paras[0].Value + "' does not exist";
}
return(false);
}
/// <summary>
/// 移除匹配值
/// </summary>
/// <param name="list">单向动态数组</param>
/// <param name="isValue">数据匹配器</param>
/// <returns>单向动态数组</returns>
public unsafe static list </*Type[0]*/ ulong /*Type[0]*/> remove
(this list </*Type[0]*/ ulong /*Type[0]*/> list, func </*Type[0]*/ ulong /*Type[0]*/, bool> isValue)
{
int count = list.count();
if (count != 0)
{
if (isValue == null)
{
log.Default.Throw(log.exceptionType.Null);
fixed(/*Type[0]*/ ulong /*Type[0]*/ *valueFixed = list.Unsafer.Array)
{
/*Type[0]*/
ulong /*Type[0]*/ *start = valueFixed, end = valueFixed + count;
while (start != end && !isValue(*start))
{
++start;
}
/*Type[0]*/
ulong /*Type[0]*/ *write = start;
while (start != end)
{
if (!isValue(*start))
{
*write++ = *start;
}
++start;
}
list.Unsafer.AddLength((int)(write - valueFixed) - count);
}
}
return(list);
}
public double GetGlobalError(List<double> inputs, List<double> expected, func f)
{
List<double> outputs = (from x in f(inputs, 1).Split(new char[] { ';' }) select Convert.ToDouble(x)).ToList<double>();
GE = 0;
for(int i=0; i<outputs.Count(); i++)
GE += Math.Abs(outputs[i]-expected[i]);
return GE;
}
public static void Euler(func f, float y, int n, float h)
{
for(float x=0; x<=n; x+=h)
{
Console.WriteLine("\t" + x + "\t" + y);
y += h * f(y);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MyTimer"/> class.
/// </summary>
/// <param name="delay">The delay.</param>
/// <param name="newFunc">The new function.</param>
/// <param name="param">The parameters.</param>
public MyTimer(int delay, func newFunc, object param)
{
delayAmount = delay;
myFunc = newFunc;
this.param = param;
//start timer now
start();
}
public static void Main(string[] args)
{
func f = new func(NewtonCooling);
for(int i=0; i<delta_t.Length; i++)
{
Console.WriteLine("delta_t = " + delta_t[i]);
Euler(f,T0,n,delta_t[i]);
}
}
private void performOnAll(func myFunc)
{
this.performOnDict(this.opponent, myFunc);
foreach (Dictionary<InputState.Move, ButtonAnimation> bundle in this.player.Values) {
this.performOnDict(bundle, myFunc);
}
this.performOnDict(this.fail, myFunc);
}
//private volatile bool gameStarted = false;
/// <summary>
/// Constructeur du jeu
/// applique l'adresse IP et change l'état du jeu a WaitingStart
/// </summary>
/// <param name="Ip">Adresse IP</param>
/// <param name="HandleClient"></param>
public Jeu(String Ip,func HandleClient)
{
ipAdress = Ip;
Lock.WaitOne();
State = GameState.WaitingStartGame;
Lock.ReleaseMutex();
UpdateAction();
AddHitSelf = HandleClient;
}
// Метод Симпсона для 100 частей на промежутке от a до b
public static double SimpIntegral(func f, double a, double b)
{
double h = (a + b) / 100;
double value = f(a) + f(b);
double temp = 0;
for (int i = 0; i < 100; i++)
temp += f(a + h / 2 * (2 * i + 1));
value += 4 * temp;
temp = 0;
for (int i = 0; i < 99; i++)
temp += f(a + (i + 1) * h);
value += 2 * temp;
return h / 6 * value;
}
/// <summary>
/// Jouer son tour
/// Envoie d'un Hit au serveur
/// </summary>
/// <param name="point">point touché</param>
/// <param name="AjoutHit"></param>
public void PlayingTurn(Point point, func AjoutHit)
{
try
{
CommUtility.SerializeAndSend(serveur.GetStream(), new Hit { Etat = Hit.HitState.NoAction, Location = point });
(new Thread(() => waitHitConfirm(AjoutHit))).Start();
}
catch (Exception)
{
Lock.WaitOne();
State = GameState.ServerDC;
Lock.ReleaseMutex();
}
}
/// <summary>
/// Attente de la comfirmation du serveur pour savoir si le Hit
/// est un Flop ou un Touché
/// </summary>
/// <param name="AjoutHit"></param>
private void waitHitConfirm(func AjoutHit)
{
object carry = null;
try
{
carry = CommUtility.ReadAndDeserialize(serveur.GetStream());
AjoutHit((Hit)carry);
Lock.WaitOne();
Thread.Sleep(300);
State = GameState.WaitingTurn;
Lock.ReleaseMutex();
UpdateAction();
}
catch(Exception e)
{
try
{
if (carry != null)
{
Result result = (Result)carry;
if(result.Etat == Result.ResultState.Victory)//Si la réponse est Victoire
{
if (result.Touche != null && result.Touche.Etat != Hit.HitState.NoAction)
AjoutHit(result.Touche);
Lock.WaitOne();
State = GameState.Victory;
EnemyShips = result.EnemyShips;
Lock.ReleaseMutex();
UpdateAction();
}
else//Si la réponse est Perdage
{
if (result.Touche != null && result.Touche.Etat != Hit.HitState.NoAction)
AjoutHit(result.Touche);
Lock.WaitOne();
State = GameState.Lose;
EnemyShips = result.EnemyShips;
Lock.ReleaseMutex();
UpdateAction();
}
}
else
throw;
}
catch (Exception)
{
Lock.WaitOne();
State = GameState.ServerDC;
Lock.ReleaseMutex();
UpdateAction();
}
}
}
static UnaryExpression()
{
getSimpleExpressions = new func<UnaryExpression, Expression>[fastCSharp.Enum.GetMaxValue<ExpressionType>(-1) + 1];
getSimpleExpressions[(int)ExpressionType.Not] = getSimpleNot;
//getSimpleExpressions[(int)expressionType.Negate] = getSimpleNegate;
//getSimpleExpressions[(int)expressionType.NegateChecked] = getSimpleNegate;
//getSimpleExpressions[(int)expressionType.UnaryPlus] = getSimpleUnaryPlus;
getSimpleExpressions[(int)ExpressionType.IsTrue] = getSimpleIsTrue;
getSimpleExpressions[(int)ExpressionType.IsFalse] = getSimpleIsFalse;
//getSimpleExpressions[(int)expressionType.Convert] = getSimpleConvert;
//getSimpleExpressions[(int)expressionType.ConvertChecked] = getSimpleConvert;
}
public int exeFunc(int a, int b, func x)
{
return x(a, b);
}
static Loger()
{
logFile = new FileStream("log.txt", FileMode.OpenOrCreate, FileAccess.Write);
logWrite = new StreamWriter(logFile);
message = MessagesSender.nothing;
}
/// <summary>
/// 删除匹配的子节点
/// </summary>
/// <param name="isRemove">删除子节点匹配器</param>
private void removeChilds(func<htmlNode, bool> isRemove)
{
if (children != null)
{
int count = children.Count;
while (--count >= 0 && !isRemove(children[count])) ;
if (count >= 0)
{
list<htmlNode>.unsafer values = new list<htmlNode>(children.Count).Unsafer;
int index = 0;
for (; index != count; ++index)
{
if (!isRemove(children[index])) values.Add(children[index]);
}
for (count = children.Count; ++index != count; values.Add(children[index])) ;
children = values.List;
}
}
}
/// <summary>
/// 删除匹配的子孙节点
/// </summary>
/// <param name="isRemove">删除节点匹配器</param>
public void Remove(func<htmlNode, bool> isRemove)
{
if (isRemove != null)
{
removeChilds(isRemove);
if (children.count() != 0)
{
htmlNode node;
list<nodeIndex> values = new list<nodeIndex>();
nodeIndex index = new nodeIndex { Values = children };
while (true)
{
if (index.Values == null)
{
if (values.Count == 0) break;
else index = values.Pop();
}
node = index.Values[index.Index];
if (node.children != null) node.removeChilds(isRemove);
if (node.children.count() == 0)
{
if (++index.Index == index.Values.Count) index.Values = null;
}
else
{
if (++index.Index != index.Values.Count) values.Add(index);
index.Values = node.children;
index.Index = 0;
}
}
}
}
}
private void performOnDict(Dictionary<InputState.Move, ButtonAnimation> animations,
func myFunc)
{
foreach (KeyValuePair<InputState.Move, ButtonAnimation> anim in animations) {
myFunc(anim.Value);
}
}
void OnDestroy()
{
OnGestureEnd = idle;
OnGestureStart = idle;
foreach (Gesture gest in g)
gest.OnAddingTouch = idle;
}
public GestureController()
{
Instance = this;
_pressed = false;
g = new List<Gesture>();
OnGestureEnd = idle;
OnGestureStart = idle;
}
public Gesture()
{
Frames = new List<MouseTouch>();
OnAddingTouch = onaddingtouch;
}
static BinaryExpression()
{
getSimpleExpressions = new func<BinaryExpression, Expression>[fastCSharp.Enum.GetMaxValue<ExpressionType>(-1) + 1];
getSimpleExpressions[(int)ExpressionType.OrElse] = getSimpleOrElse;
getSimpleExpressions[(int)ExpressionType.AndAlso] = getSimpleAndAlso;
getSimpleExpressions[(int)ExpressionType.Equal] = getSimpleEqual;
getSimpleExpressions[(int)ExpressionType.NotEqual] = getSimpleNotEqual;
getSimpleExpressions[(int)ExpressionType.GreaterThanOrEqual] = getSimpleGreaterThanOrEqual;
getSimpleExpressions[(int)ExpressionType.GreaterThan] = getSimpleGreaterThan;
getSimpleExpressions[(int)ExpressionType.LessThan] = getSimpleLessThan;
getSimpleExpressions[(int)ExpressionType.LessThanOrEqual] = getSimpleLessThanOrEqual;
//getSimpleExpressions[(int)expressionType.Add] = getSimpleAdd;
//getSimpleExpressions[(int)expressionType.AddChecked] = getSimpleAdd;
//getSimpleExpressions[(int)expressionType.Subtract] = getSimpleSubtract;
//getSimpleExpressions[(int)expressionType.SubtractChecked] = getSimpleSubtract;
//getSimpleExpressions[(int)expressionType.Multiply] = getSimpleMultiply;
//getSimpleExpressions[(int)expressionType.MultiplyChecked] = getSimpleMultiply;
//getSimpleExpressions[(int)expressionType.Divide] = getSimpleDivide;
//getSimpleExpressions[(int)expressionType.Modulo] = getSimpleModulo;
//getSimpleExpressions[(int)expressionType.Power] = getSimplePower;
//getSimpleExpressions[(int)expressionType.Or] = getSimpleOr;
//getSimpleExpressions[(int)expressionType.And] = getSimpleAnd;
//getSimpleExpressions[(int)expressionType.ExclusiveOr] = getSimpleExclusiveOr;
//getSimpleExpressions[(int)expressionType.LeftShift] = getSimpleLeftShift;
//getSimpleExpressions[(int)expressionType.RightShift] = getSimpleRightShift;
}
/// <summary>
/// Constructor which inits the TranslationFunction and RotationFunction attributes.
/// </summary>
public Sensor()
{
//m_Rotation.Sensor = this;
//m_Translation.Sensor = this;
m_TranslationFunction = set_Function(functions.none);
m_RotationFunction = set_Function(functions.none);
}
public static void init(string ini = "init.ini")
{
FileStream iniFile = new FileStream(ini, FileMode.Open, FileAccess.Read);
StreamReader initRead = new StreamReader(iniFile);
string data = initRead.ReadToEnd();
string[] macro = data.Split('#');
for(int i = 1; i < macro.Length; ++i)
{
// Console.WriteLine(macro[i]);
switch (macro[i])
{
case "NUMBER":
// message += MessagesSender.number;
Console.WriteLine("NUMBER");
break;
case "TIME":
// message += MessagesSender.time;
Console.WriteLine("TIME");
break;
case "ERROR":
// message += MessagesSender.error;
Console.WriteLine("ERROR");
break;
case "MESSAGE":
message += MessagesSender.message;
Console.WriteLine("MESSAGE");
break;
}
// message += MessagesSender.space;
}
// message += MessagesSender.endl;
initDone = true;
initRead.Close();
iniFile.Close();
}
/// <summary>
/// 删除匹配的子节点
/// </summary>
/// <param name="isRemove">删除子节点匹配器</param>
public void RemoveChilds(func<htmlNode, bool> isRemove)
{
if (isRemove != null) removeChilds(isRemove);
}
/// <summary>
/// 节点筛选器解析
/// </summary>
/// <param name="start">起始字符位置</param>
/// <param name="end">结束字符位置</param>
private filter(char* start, char* end)
{
filterFixedMap = filterMap.Byte;
switch (*start)
{
case '/':
filterMethod = filterChild;
if (++start != end && start != (end = next(start, end)))
{
char* index = end;
if (*--index == ']' && (index = unsafer.String.Find(start, index, '[')) != null)
{
unsafer.String.ToLower(start, index);
getValue(start, index);
getIndex(++index, --end);
}
else
{
unsafer.String.ToLower(start, end);
getValues(start, end);
}
}
break;
case '.':
filterMethod = filterClass;
if (++start != end) getValues(start, end = next(start, end));
break;
case '#':
name = "id";
filterMethod = filterValue;
if (++start != end) getValues(start, end = next(start, end));
break;
case '*':
name = "name";
filterMethod = filterValue;
if (++start != end)
{
end = next(start, end);
unsafer.String.ToLower(start, end);
getValues(start, end);
}
break;
case ':':
name = "type";
filterMethod = filterValue;
if (++start != end) getValues(start, end = next(start, end));
break;
case '@':
filterMethod = filterValue;
if (++start != end)
{
end = next(start, end);
char* value = unsafer.String.Find(start, end, '=');
if (value != null)
{
getName(start, value);
if (++value == end) this.value = string.Empty;
else getValues(value, end);
}
else getName(start, end);
}
break;
default:
filterMethod = filterNode;
if (*start == '\\') ++start;
if (start != end)
{
end = next(start, end);
unsafer.String.ToLower(start, end);
getValues(start, end);
}
break;
}
}
static uri()
{
Assembly uriAssembly = typeof(Uri).Assembly;
uriInfo = fieldGetValue.Creator.Create(typeof(Uri), "m_Info");
uriFlags = fieldGetSetValue.Creator.Create(typeof(Uri), "m_Flags");
uriMoreInfo = fieldGetValue.Creator.Create(uriAssembly, "System.Uri+UriInfo", "MoreInfo", false);
uriAbsolute = fieldSetValue.createFieldSetValue<string>.Default.Create(uriAssembly, "System.Uri+MoreInfo", "AbsoluteUri", false);
IsUriField = uriInfo != null && uriFlags.Getter != null && uriFlags.Setter != null && uriMoreInfo != null && uriAbsolute != null;
}
public Gesture()
{
Frames = new List<MouseTouch>();
OnGestureStay = onaddingtouch;
}
