private void ThrowIfContainVariable(SingleType variable, IType expr)
{
if (expr is Implication)
{
var impl = expr as Implication;
if (impl.Left.Equals(variable))
{
throw new UnificatorUnresolvedExpection("The system can't be resolved");
}
if (impl.Right.Equals(variable))
{
throw new UnificatorUnresolvedExpection("The system can't be resolved");
}
if (!(impl.Left is SingleType))
{
ThrowIfContainVariable(variable, (Implication)impl.Left);
}
if (!(impl.Right is SingleType))
{
ThrowIfContainVariable(variable, (Implication)impl.Right);
}
}
else
if (expr is SingleType)
{
//It can happend, we will remove x = x on next iteration
//if (expr.Equals(variable)) throw new Exception();
}
else
{
throw new Exception("Unsupported type");
}
}
private IType Substitute(IType expr, SingleType variable, IType toSubst)
{
if (expr is SingleType)
{
if (expr.Equals(variable))
{
return(toSubst);
}
return(expr);
}
else if (expr is Implication)
{
var impl = expr as Implication;
var left = Substitute(impl.Left, variable, toSubst);
var right = Substitute(impl.Right, variable, toSubst);
if (left != impl.Left || right != impl.Right)
{
return(new Implication(left, right));
}
return(impl);
}
else
{
throw new Exception("Unsupported type");
}
}
void Start()
{
stageObj = Instantiate(stage [stageNo]);
stageObj.transform.parent = this.gameObject.transform;
SingleInitialize();
singleType_g = SingleType.None;
enemyMgr = GameObject.Find("EnemyMgr");
}
public static SingleType CreateSingleType(int keyProp, global::Namespace.Foo.Color colorProp)
{
SingleType singleType = new SingleType();
singleType.KeyProp = keyProp;
singleType.ColorProp = colorProp;
return(singleType);
}
private Equation Substitute(Equation eq, SingleType variable, IType toSubst)
{
var left = Substitute(eq.Left, variable, toSubst);
var right = Substitute(eq.Right, variable, toSubst);
if (left != eq.Left || right != eq.Right)
{
return(new Equation(left, right));
}
return(eq);
}
/// <summary>
/// Validate a single type.
/// </summary>
/// <param name="e">
/// is the expression. </param>
/// <returns> null. </returns>
public virtual object visit(SingleType e)
{
QName type = e.type();
if (!expandItemTypeQName(type))
{
reportBadPrefix(type.prefix());
}
return(null);
}
public void FromString(string value, float expected, System.Globalization.NumberFormatInfo numberFormat = null)
{
if (numberFormat is null)
{
Assert.Equal(expected, SingleType.FromString(value));
Assert.Equal(expected, SingleType.FromString(value, System.Globalization.NumberFormatInfo.InvariantInfo));
}
else
{
Assert.Equal(expected, SingleType.FromString(value, numberFormat));
}
}
public SingleValue(SingleType type = SingleType.Void)
{
Type = type;
if (type == SingleType.List)
{
Moments = new List <Moment>();
}
if (type == SingleType.Segments)
{
Segments = new List <Segment>();
}
}
public async Task <Result <JobTaskStatus> > SingleSetting(SingleType type, string name, long sid)
{
var re = await Http.PostHttpAsync <Result <JobTaskStatus> >($"job/task/{type}/{sid}", nodeName : await SessionStorage.GetItemAsync <string>("nodename"));
if (re.Success)
{
await JSRuntime.DoVoidAsync("toastrs", new[] { "success", name, re.Message });
await Load();
}
else
{
await JSRuntime.DoVoidAsync("toastrs", new[] { "error", name, re.Message });
}
return(re);
}
/// <summary>
/// テストシーン移行
/// </summary>
void TestScene()
{
if (InputMgr.fire6 == true || Input.GetKeyDown(KeyCode.Space))
{
mainTiming_p = MainTiming.ProcessEnd;
SystemMgr.loadBackBoradUsabale = true;
singleType_g = SingleType.Clear;
}
else if (InputMgr.fire7 == true)
{
mainTiming_p = MainTiming.ProcessEnd;
SystemMgr.loadBackBoradUsabale = true;
singleType_g = SingleType.Over;
}
else if (InputMgr.fire5 == true)
{
enemyMgr.GetComponent <EnemyMgr> ().EnemyBreak();
}
}
/// <summary>
/// Validate a cast expression.
/// </summary>
/// <param name="cexp">
/// is the expression. </param>
/// <returns> null. </returns>
public virtual object visit(CastExpr cexp)
{
printBinExpr("CAST", cexp);
SingleType st = (SingleType)cexp.right();
QName type = st.type();
[email protected] qName = type.asQName();
Function f = _sc.resolveFunction(qName, 1);
if (f == null)
{
reportError(new StaticFunctNameError("Type does not exist: " + type.ToString()));
}
cexp.set_function(f);
_resolvedFunctions.Add(qName);
return(null);
}
private IType CalculateType(LambdaExpression lambda, out HashSet <Equation> equations, Dictionary <Variable, IType> type)
{
if (lambda is Abstraction)
{
var abstraction = lambda as Abstraction;
IType prev = null;
var variableType = type[abstraction.Variable] = new SingleType("'t" + abstraction.Variable.Name);
var exprType = CalculateType(abstraction.Expression, out equations, type);
type.Remove(abstraction.Variable);
return(new Implication(variableType, exprType));
}
else if (lambda is Application)
{
var application = lambda as Application;
HashSet <Equation> left;
HashSet <Equation> right;
var leftType = CalculateType(application.Left, out left, type);
var rightType = CalculateType(application.Right, out right, type);
equations = new HashSet <Equation>(left);
foreach (var e in right)
{
equations.Add(e);
}
var newType = new SingleType(NextName());
equations.Add(new Equation(leftType, new Implication(rightType, newType)));
return(newType);
}
else if (lambda is Variable)
{
var variable = lambda as Variable;
equations = new HashSet <Equation>();
type[variable] = new SingleType("'t" + variable.Name);
return(type[variable]);
}
throw new Exception("Unsupported type");
}
protected internal float SSIncomeLimit(int intTaxYear)
{
//OleDbCommand command1 = new OleDbCommand();
//command1.Connection = this.mcnnTaxTables;
float single1 = 0f;
//string text1 = ("SELECT TOP 1 [TAXYEAR],* FROM TR6 Where [TR124] = 'SS' And [TaxYear]<=" + StringType.FromInteger(intTaxYear)) + " Order by [TaxYear] DESC";
string text1 = "[TR124] = 'SS' And [TaxYear]<=" + StringType.FromInteger(intTaxYear);
//command1.CommandText = text1;
//OleDbDataReader reader1 = command1.ExecuteReader();
DataRow[] Rows = GlobalClass.TaxTable.Tables["TR6"].Select(text1);
//while (reader1.Read())
{
//single1 = SingleType.FromObject(reader1["TR127"]);
single1 = SingleType.FromObject(Rows[0]["TR127"]);
}
//reader1.Close();
//command1.Dispose();
return(single1);
}
public static bool IsValidCSharpIdentifier(string toTest)
{
if (toTest.Length == 0) // obviously..?
{
return(false);
}
if (SingleType.IsCSharpKeyword(toTest)) // best to avoid any complications
{
return(false);
}
char[] letters = toTest.ToCharArray();
char first = letters[0];
if (first != '_' && !validFirstChars.Contains(CharUnicodeInfo.GetUnicodeCategory(first)))
{
return(false);
}
foreach (char c in letters)
{
if (!validCSharpChars.Contains(CharUnicodeInfo.GetUnicodeCategory(c)))
{
return(false);
}
}
return(true);
// TODO: fix this regex method, replace the above method with it,
// and get rid of the three UnicodeCategory arrays
// (regex method found at https://stackoverflow.com/a/1904462/4036588)
//const string start = @"(\p{Lu}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Lo}|\p{Nl})";
//const string extend = @"(\p{Mn}|\p{Mc}|\p{Nd}|\p{Pc}|\p{Cf})";
//Regex ident = new Regex(string.Format("{0}({0}|{1})*", start, extend));
//toTest = toTest.Normalize();
//return ident.IsMatch(toTest);
}
public static Object Int(Object Number)
{
if (Number == null)
{
throw new ArgumentNullException("Number");
}
switch (ObjectType.GetTypeCode(Number))
{
case TypeCode.Boolean:
case TypeCode.Char:
case TypeCode.SByte:
case TypeCode.Byte:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
return(Int(IntegerType.FromObject(Number)));
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
return(Number);
case TypeCode.Single:
return(Int(SingleType.FromObject(Number)));
case TypeCode.Double:
return(Int(DoubleType.FromObject(Number)));
case TypeCode.Decimal:
return(Int(DecimalType.FromObject(Number)));
case TypeCode.String:
return(Int(DoubleType.FromString
(StringType.FromObject(Number))));
}
throw new ArgumentException(S._("VB_InvalidNumber"), "Number");
}
public void FromObject_ThrowsInvalidCastException(object value)
{
Assert.Throws <InvalidCastException>(() => SingleType.FromObject(value));
}
/// <summary>
/// Performs a bitwise NOT on a generic value.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="first"></param>
/// <param name="second"></param>
/// <returns></returns>
public static T Not <T>(T value)
{
return(SingleType <T> .Not(value));
}
/// <summary>
/// Calculates the absolute (non-negative) value of a generic value.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <returns></returns>
public static T Abs <T>(T value)
{
return(SingleType <T> .Abs(value));
}
public void FromObject_ThrowsOverflowException(object value)
{
Assert.Throws <OverflowException>(() => SingleType.FromObject(value));
}
/// <summary>
/// Calculates the modulo of a generic value.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="first"></param>
/// <param name="second"></param>
/// <returns></returns>
public static T Modulo <T>(T first, T second)
{
return(SingleType <T> .Modulo(first, second));
}
/// <summary>
/// Negates a generic value.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <returns></returns>
public static T Negate <T>(T value)
{
return(SingleType <T> .Negate(value));
}
/// <summary>
/// Determines whether one generic value is less than or equal to the other.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="first"></param>
/// <param name="second"></param>
/// <returns></returns>
public static bool LessThanOrEqual <T>(T first, T second)
{
return(SingleType <T> .LessThanOrEqual(first, second));
}
/// <summary>
/// Performs a linear interpolation on a two generic values using a blend factor.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="first"></param>
/// <param name="second"></param>
/// <param name="factor"></param>
/// <returns></returns>
public static T Lerp <T>(T first, T second, float factor)
{
return(SingleType <T> .Lerp(first, second, factor));
}
/// <summary>
/// Determines whether one generic value is greater than or equal to the other.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="first"></param>
/// <param name="second"></param>
/// <returns></returns>
public static bool GreaterThanOrEqual <T>(T first, T second)
{
return(SingleType <T> .GreaterThanOrEqual(first, second));
}
public void FromString_Other(string value, float expected)
{
Assert.Equal(expected, SingleType.FromString(value));
}
public void FromString_ThrowsInvalidCastException(string value)
{
Assert.Throws <InvalidCastException>(() => SingleType.FromString(value));
}
/// <summary>
/// Performs a bitwise exclusive OR on two generic values.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="first"></param>
/// <param name="second"></param>
/// <returns></returns>
public static T Xor <T>(T first, T second)
{
return(SingleType <T> .Xor(first, second));
}
public void FromString_ThrowsOverflowException(string value)
{
Assert.Throws <OverflowException>(() => SingleType.FromString(value));
}
/// <summary>
/// Performs a bitwise AND on two generic values.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="first"></param>
/// <param name="second"></param>
/// <returns></returns>
public static T And <T>(T first, T second)
{
return(SingleType <T> .And(first, second));
}
/// <summary>
/// Determines whether two generic values are equal.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="first"></param>
/// <param name="second"></param>
/// <returns></returns>
public static bool Equal <T>(T first, T second)
{
return(SingleType <T> .Equal(first, second));
}
