/// <summary>
/// 改变数字
/// </summary>
/// <param name="changeObj">Change object.</param>
/// <param name="targetBgCellObj">Target background cell object.</param>
public void ChangeNumber(GameObject changeObj, GameObject targetBgCellObj)
{
NumberEntity entity = changeObj.GetComponent <NumberCell>().NumberEntity;
if (entity.CurrentNumberValue + 1 > GlobalConfig.MaxNubmberValue)
{
GlobalConfig.MaxNubmberValue = entity.CurrentNumberValue + 1;
}
//分数设置
ScoreManage.SetScore(entity.CurrentNumberValue + 1);
var numberObj = CommonToolkit.LoadNumberResource(entity.CurrentNumberValue);
GameObject newGameObject = NumberConstructor.CreateNumber(
numberObj,
targetBgCellObj,
targetBgCellObj.GetComponent <BackgroundCell>().BackgroundCellEntity.Index,
entity.CurrentNumberValue + 1);
targetBgCellObj.GetComponent <BackgroundCell>().DisposeNumber();
CommonToolkit.SetNumberObjectToBackgroundCell(targetBgCellObj, newGameObject);
GameObject scoreNumberObj = CommonToolkit.GetScoreNumberObject(targetBgCellObj, entity.CurrentNumberValue + 1);
scoreNumberObj.GetComponent <Animation>().Play("AnimationScoreRun");
}
public IActionResult Post([FromBody] NumberEntity item)
{
object result;
var numbers = _repository.Get().OrderBy(x => x.Number).ToList();
NumberEntity number = numbers.LastOrDefault();
if (number != default(NumberEntity) && number.Number == item.Number)
{
ExceptionResult exp = new ExceptionResult()
{
Error = "Exception 1: number is already added",
Type = "1"
};
result = BadRequest(exp);
}
else if (number != default(NumberEntity) && number.Number > item.Number)
{
ExceptionResult exp = new ExceptionResult()
{
Error = "Exception 2: number is less than added",
Type = "2"
};
result = BadRequest(exp);
}
else
{
NumberEntity new_number = _repository.Add(item);
Models.OkResult ok = new Models.OkResult()
{
Result = new_number.Number + 1
};
result = Ok(ok);
}
return((IActionResult)result);
}
public void Test3()
{
var eq = new NumberEntity(1);
var roots = eq.SolveNt(x);
AssertRootCount(roots, 0);
}
public NumberEntity Add(NumberEntity item)
{
NumberEntity result = null;
_numbers.InsertOne(item);
result = _numbers.Find(number => number.Number == item.Number).FirstOrDefault();
return(result);
}
/// <summary>
/// solves ax3 + bx2 + cx + d
/// </summary>
/// <param name="a">
/// Coefficient of x^3
/// </param>
/// <param name="b">
/// Coefficient of x^2
/// </param>
/// <param name="c">
/// Coefficient of x
/// </param>
/// <param name="d">
/// Free coefficient
/// </param>
/// <returns>
/// Set of roots
/// </returns>
internal static Set SolveCubic(Entity a, Entity b, Entity c, Entity d)
{
// en: https://en.wikipedia.org/wiki/Cubic_equation
// ru: https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%9A%D0%B0%D1%80%D0%B4%D0%B0%D0%BD%D0%BE
// TODO (to remove sympy code!)
Set res;
if (TreeAnalyzer.IsZero(d))
{
res = SolveQuadratic(a, b, c);
res.Add(0);
return(res);
}
if (TreeAnalyzer.IsZero(a))
{
return(SolveQuadratic(b, c, d));
}
res = new Set();
var coeff = MathS.i * MathS.Sqrt(3) / 2;
var u1 = new NumberEntity(1);
var u2 = SySyn.Rational(-1, 2) + coeff;
var u3 = SySyn.Rational(-1, 2) - coeff;
var D0 = MathS.Sqr(b) - 3 * a * c;
var D1 = (2 * MathS.Pow(b, 3) - 9 * a * b * c + 27 * MathS.Sqr(a) * d).InnerSimplify();
var C = MathS.Pow((D1 + MathS.Sqrt(MathS.Sqr(D1) - 4 * MathS.Pow(D0, 3))) / 2, Number.CreateRational(1, 3));
foreach (var uk in new List <Entity> {
u1, u2, u3
})
{
Entity r;
if (Const.EvalIfCan(C) == 0 && Const.EvalIfCan(D0) == 0)
{
r = -(b + uk * C) / 3 / a;
}
else
{
r = -(b + uk * C + D0 / C / uk) / 3 / a;
}
res.Add(r);
}
return(res);
}
public NumberEntity Add(NumberEntity item)
{
NumberEntity result = null;
long oldListLength = _context.Base.ListLength(_collection);
if (_context.Base != null)
{
long newListLength = _context.Base.ListRightPush(_collection, JsonConvert.SerializeObject(item));
if (newListLength > oldListLength)
{
result = Get().ToList().Find(x => x.Number == item.Number);
}
}
return(result);
}
public bool Delete(NumberEntity item)
{
bool result = false;
List <NumberEntity> numbers = Get().ToList();
NumberEntity number = numbers.Find(x => x.Number == item.Number);
if (_context.Base != null)
{
long removed = _context.Base.ListRemove(_collection, JsonConvert.SerializeObject(numbers));
if (removed > 0)
{
result = true;
}
}
return(result);
}
public static IObservable <StateChange <NumberEntity, NumericEntityState <NumberAttributes> > > StateAllChangesWithCurrent(this NumberEntity entity)
{
return(entity.StateAllChangesWithCurrent <NumberEntity, NumericEntityState <NumberAttributes>, NumberAttributes>());
}
/// <summary>
/// Divides one polynom over another one
/// </summary>
/// <param name="p"></param>
/// <param name="q"></param>
/// <returns></returns>
internal static Entity DividePolynoms(Entity p, Entity q)
{
// ---> (x^0.6 + 2x^0.3 + 1) / (x^0.3 + 1)
var replacementInfo = GatherAllPossiblePolynomials(p + q, replaceVars: true).replacementInfo;
var originalP = p;
var originalQ = q;
// TODO remove extra copy
p = p.DeepCopy();
q = q.DeepCopy();
foreach (var pair in replacementInfo)
{
FindAndReplace(ref p, pair.Value, new VariableEntity(PolyInfo.NewVarName(pair.Key)));
FindAndReplace(ref q, pair.Value, new VariableEntity(PolyInfo.NewVarName(pair.Key)));
}
var monoinfoQ = GatherAllPossiblePolynomials(q.Expand(), replaceVars: false).monoInfo;
var monoinfoP = GatherAllPossiblePolynomials(p.Expand(), replaceVars: false).monoInfo;
string polyvar = null;
// TODO use Linq to find polyvar
// First attempt to find polynoms
foreach (var pair in monoinfoQ)
{
if (pair.Value != null && monoinfoP.ContainsKey(pair.Key) && monoinfoP[pair.Key] != null)
{
polyvar = pair.Key;
break;
}
}
// cannot divide, return unchanged
if (string.IsNullOrEmpty(polyvar))
{
return(originalP / originalQ);
}
var maxpowQ = monoinfoQ[polyvar].Keys.Max();
var maxpowP = monoinfoP[polyvar].Keys.Max();
var maxvalQ = monoinfoQ[polyvar][maxpowQ];
var maxvalP = monoinfoP[polyvar][maxpowP];
var result = new Dictionary <decimal, Entity>();
// TODO: add case where all powers are non-positive
// for now just return polynomials unchanged
if (maxpowP < maxpowQ)
{
return(originalP / originalQ);
}
// possibly very long process
while (maxpowP >= maxpowQ)
{
// KeyPair is ax^n with Key=n, Value=a
decimal deltapow = maxpowP - maxpowQ;
Entity deltamul = maxvalP / maxvalQ;
result[deltapow] = deltamul;
foreach (var n in monoinfoQ[polyvar])
{
// TODO: precision loss can happen here. MUST be fixed somehow
decimal newpow = deltapow + n.Key;
if (!monoinfoP[polyvar].ContainsKey(newpow))
{
monoinfoP[polyvar][newpow] = -deltamul * n.Value;
}
else
{
monoinfoP[polyvar][newpow] -= deltamul * n.Value;
}
}
if (monoinfoP[polyvar].ContainsKey(maxpowP))
{
monoinfoP[polyvar].Remove(maxpowP);
}
if (monoinfoP[polyvar].Count == 0)
{
break;
}
maxpowP = monoinfoP[polyvar].Keys.Max();
maxvalP = monoinfoP[polyvar][maxpowP];
}
// check if all left in P is zero. If something left, division is impossible => return P / Q
var Zero = new NumberEntity(0);
foreach (var coef in monoinfoP[polyvar])
{
var simplified = coef.Value.Simplify();
if (simplified != Zero)
{
return(originalP / originalQ);
}
}
Entity res = Number.Create(0);
foreach (var pair in result)
{
res += pair.Value.Simplify(5) * MathS.Pow(new VariableEntity(polyvar), pair.Key);
}
// TODO: we know that variable is the same but with suffux '_r'. This foreach loop can be speeded-up
while (replacementInfo.Any(rep => res.FindSubtree(new VariableEntity(PolyInfo.NewVarName(rep.Key))) != null))
{
foreach (var subst in replacementInfo)
{
FindAndReplace(ref res, new VariableEntity(PolyInfo.NewVarName(subst.Key)), subst.Value);
}
}
return(res);
}
public bool Delete(NumberEntity item)
{
DeleteResult result = _numbers.DeleteOne(number => number.Id == item.Id);
return(result.IsAcknowledged);
}
