public IHttpActionResult Post(Radical radical)
{
if (!ModelState.IsValid) {
return BadRequest(this.ModelState);
}
var user = this.User as ClaimsPrincipal;
if (user.HasClaim("CanAddRadicals", "true")) {
_service.SaveRad(radical);
return Created("", radical);
}
else { return Unauthorized(); }
}
public void CalculateTest(double firstValue, double expected)
{
var calculator = new Radical();
var actualResult = calculator.Calculate(firstValue);
Assert.AreEqual(expected, actualResult);
}
public static Entry[] GetFields(object obj, bool seen)
{
var type = obj.GetType();
var accessors = GetAccessors(type);
#if US_LOGGING
if (Radical.IsLogging())
{
Radical.Log("[Available Fields]");
Radical.IndentLog();
accessors[1].Select(a => { Radical.Log("{0}", a.FieldInfo.Name); return(a); }).ToList();
Radical.OutdentLog();
Radical.Log("[/Available Fields]");
}
#endif
return((from a in accessors[seen ? 1 : 3]
let value = a.Get(obj)
select new Entry()
{
FieldInfo = a.FieldInfo,
MustHaveName = true,
Value = value,
IsStatic = a.IsStatic
}).ToArray());
}
// Token: 0x0600000D RID: 13 RVA: 0x00002290 File Offset: 0x00000490
public GameObject GetHullPlate()
{
bool flag = this.Texture == null;
GameObject result;
if (flag)
{
result = null;
}
else
{
GameObject gameObject = Resources.Load <GameObject>("Submarine/Build/DioramaHullPlate");
GameObject gameObject2 = UnityEngine.Object.Instantiate <GameObject>(gameObject);
MeshRenderer component = Radical.FindChild(gameObject2, "Icon").GetComponent <MeshRenderer>();
component.material.mainTexture = this.Texture;
PrefabIdentifier component2 = gameObject2.GetComponent <PrefabIdentifier>();
component2.ClassId = this.Info.InternalName;
TechTag component3 = gameObject2.GetComponent <TechTag>();
component3.type = this.TechType;
Constructable component4 = gameObject2.GetComponent <Constructable>();
component4.techType = this.TechType;
result = gameObject2;
}
return(result);
}
public void CalculateRadicalTest(double firstValue, double expected)
{
IOneArgumentCalculator calculator = new Radical();
double result = calculator.Calculate(firstValue);
Assert.AreEqual(expected, result);
}
public void NormalizeCoefficients()
{
RadicalSumRatio total = 0;
foreach (KeyValuePair <Tuple <Rational, Rational>, CBNode> kvp in grid)
{
if (kvp.Value.m1 + kvp.Value.m2 == m)
{
total += (kvp.Value.rawCoefficient * kvp.Value.rawCoefficient);
}
}
foreach (KeyValuePair <Tuple <Rational, Rational>, CBNode> kvp in grid)
{
if (kvp.Value.m1 + kvp.Value.m2 == m)
{
if (total.IsRational)
{
var normalizer = new Radical(total.ToRational());
kvp.Value.normalizedCoefficient = kvp.Value.rawCoefficient / normalizer;
kvp.Value.status = CBNode.NormalizationStatus.NORMALIZED;
}
else
{
kvp.Value.normalizedCoefficient = (kvp.Value.rawCoefficient * kvp.Value.rawCoefficient) / total;
kvp.Value.sign = kvp.Value.rawCoefficient >= 0 ? 1 : -1;
kvp.Value.status = CBNode.NormalizationStatus.NORM_SQUARED;
}
}
}
}
public void ConversionTests()
{
// [3*sqrt(2) + (7/2)*sqrt(3)] / [(-9/3)*sqrt(2) + (-14/4)*sqrt(3)] = -1
var b11 = new Radical(3, 2);
var b12 = new Radical(new Rational(7, 2), 3);
var b13 = new Radical(new Rational(-9, 3), 2);
var b14 = new Radical(new Rational(-14, 4), 3);
var c11 = new RadicalSum(new Radical[2] {
b11, b12
});
var c12 = new RadicalSum(new Radical[2] {
b13, b14
});
var cr1 = new RadicalSumRatio(c11, c12);
bool actual11 = cr1.IsRational;
var actual12 = cr1.ToRational();
bool expected11 = true;
var expected12 = new Rational(-1);
// (3*sqrt(2)) / ((5/3)*sqrt(3)) = (9/5)*sqrt(2/3) = (3/5)*sqrt(6)
var b21 = new RadicalSumRatio(3, 2);
var b22 = new RadicalSumRatio(new Rational(5, 3), 3);
var b23 = b21 / b22;
var actual21 = b23.IsRational;
var actual22 = b23.ToDouble();
var expected21 = false;
double expected22 = 1.4696938456699068589183704448235;
Assert.Equal(expected11, actual11);
Assert.Equal(expected12, actual12);
Assert.Equal(expected21, actual21);
Assert.Equal(expected22.ToString("0.000000"), actual22.ToString("0.000000"));
}
void OnGUI()
{
if (GUILayout.Button("Save"))
{
//Save the game with a prefix of Game
var t = DateTime.Now;
LevelSerializer.SaveGame("Game");
Radical.CommitLog();
Debug.Log(string.Format("{0:0.000}", (DateTime.Now - t).TotalSeconds));
}
//Check to see if there is resume info
if (LevelSerializer.CanResume)
{
if (GUILayout.Button("Resume"))
{
LevelSerializer.Resume();
}
}
if (LevelSerializer.SavedGames.Count > 0)
{
GUILayout.Label("Available saved games");
//Look for saved games under the given player name
foreach (var g in LevelSerializer.SavedGames[LevelSerializer.PlayerName])
{
if (GUILayout.Button(g.Caption))
{
g.Load();
}
}
}
}
void IDeserialized.Deserialized()
{
try
{
Loom.QueueOnMainThread(delegate
{
foreach (RadicalRoutine current in this.Running)
{
try
{
if (current.trackedObject)
{
current.trackedObject.StartCoroutine(current.enumerator);
}
else
{
base.StartCoroutine(current.enumerator);
}
}
catch (Exception ex2)
{
Radical.LogError("Problem starting radical coroutine " + ex2.ToString());
}
}
}, 0.02f);
}
catch (Exception ex)
{
Radical.LogError("Problem queing restart for radical routines " + ex.ToString());
}
}
private void Update()
{
if (TheForest.Utils.Input.GetButtonDown("Save"))
{
DateTime now = DateTime.Now;
LevelSerializer.SaveGame("Game");
Radical.CommitLog();
Debug.Log(string.Format("{0:0.000}", (DateTime.Now - now).TotalSeconds));
}
if (LevelSerializer.CanResume && GUILayout.Button("Resume", new GUILayoutOption[0]))
{
LevelSerializer.Resume();
}
if (LevelSerializer.SavedGames.Count > 0)
{
GUILayout.Label("Available saved games", new GUILayoutOption[0]);
foreach (LevelSerializer.SaveEntry saveEntry in LevelSerializer.SavedGames[LevelSerializer.PlayerName])
{
if (GUILayout.Button(saveEntry.Caption, new GUILayoutOption[0]))
{
saveEntry.Load();
}
}
}
}
public GetSetGeneric(PropertyInfo info)
{
Name = info.Name;
Info = info;
CollectionType = Info.PropertyType.GetInterface("IEnumerable", true) != null;
var getMethod = info.GetGetMethod(true);
var setMethod = info.GetSetMethod(true);
if (getMethod == null)
{
Get = (o) => {
return(info.GetValue(o, null));
};
Set = (o, v) => {
info.SetValue(o, v, null);
};
return;
}
Get = (o) => {
return(getMethod.Invoke(o, null));
};
Set = (o, v) => {
try {
setMethod.Invoke(o, new [] { v });
} catch (Exception e) {
Radical.LogWarning(string.Format("When setting {0} to {1} found {2}:", o.ToString(), v.ToString(), e.ToString()));
}
};
}
void IDeserialized.Deserialized()
{
try
{
Loom.QueueOnMainThread(() => {
foreach (var routine in Running)
{
try
{
if (routine.trackedObject)
{
routine.trackedObject.StartCoroutine(routine.enumerator);
}
else
{
StartCoroutine(routine.enumerator);
}
}
catch (Exception e)
{
Radical.LogError("Problem starting radical coroutine " + e.ToString());
}
}
}, 0.02f);
}
catch (Exception e)
{
Radical.LogError("Problem queing restart for radical routines " + e.ToString());
}
}
public override object Load(object[] data, object instance)
{
if (instance != null)
{
return(instance);
}
#if US_LOGGING
if (!((bool)data [1]))
{
Radical.Log("[[Disabled, will not be set]]");
}
Radical.Log("GameObject: {0}", data [0]);
#endif
if (data.Length > 3)
{
var asset = SaveGameManager.Instance.GetAsset((SaveGameManager.AssetReference)data[3]) as GameObject;
return(asset);
}
return(instance ?? new UnitySerializer.DeferredSetter((d) => {
return UniqueIdentifier.GetByName((string)data [0]);
})
{
enabled = (bool)data [1]
});
}
public override object Load(object[] data, object instance)
{
#if US_LOGGING
Radical.Log("Vector3: {0},{1},{2}", data [0], data [1], data [2]);
#endif
return(new Vector2((float)data [0], (float)data [1]));
}
public void NthRootTest()
{
var testCases = new List <Tuple <Radical, Radical> >()
{
// Nth-Root[n:3](8)
new Tuple <Radical, Radical>(
Radical.NthRoot(8, 3),
new Radical(2, 1)),
// Nth-Root[n:4](4) = 2^(2/4) = 2^(1/2) = Sqrt(2)
new Tuple <Radical, Radical>(
Radical.NthRoot(4, 4),
new Radical(2)),
// Nth-Root[n:2](Sqrt(2)) = Nth-Root[n:4](2)
new Tuple <Radical, Radical>(
Radical.NthRoot(Radical.Sqrt(2), 2),
new Radical(1, 2, 4)),
// Nth-Root[n:3](125) = 5
new Tuple <Radical, Radical>(
Radical.NthRoot(125, 3),
5),
// Nth-Root[m:5]((5/7)*Nth-Root[n:3](11))
// = (1/7)Nth-Root[n:15](125*13841287201*11)
// = (1/7)Nth-Root[n:15](19031769901375)
// = 1.0969847037974137166744190628521
new Tuple <Radical, Radical>(
Radical.NthRoot(new Radical(new Rational(5, 7), 11, 3), 5),
new Radical(new Rational(1, 7), BigInteger.Parse("19031769901375"), 15)),
};
foreach (var testCase in testCases)
{
Assert.Equal(testCase.Item2, testCase.Item1);
}
}
public static Entry[] GetFields(object obj)
{
var type = obj.GetType().TypeHandle;
var accessors = GetAccessors(type);
#if US_LOGGING
if (Radical.IsLogging())
{
Radical.Log("[Available Fields]");
Radical.IndentLog();
accessors[1].Select(a => { Radical.Log("{0}", a.FieldInfo.Name); return(a); }).ToList();
Radical.OutdentLog();
Radical.Log("[/Available Fields]");
}
#endif
return((from a in accessors[1]
let value = a.Get(obj)
where value != null && !value.Equals(a.Vanilla)
select new Entry()
{
FieldInfo = a.FieldInfo,
MustHaveName = true,
Value = value
}).ToArray());
}
public void Bruteforce2()
{
Stopwatch clock = Stopwatch.StartNew();
long result = 0;
long limit = 120000;
Radical[] radicals = new Radical[limit + 1];
for (int i = 0; i < radicals.Length; i++)
{
radicals[i] = new Radical(1, i);
}
for (int i = 2; i <= limit; i++)
{
if (radicals[i].rad == 1)
{
radicals[i].rad = i;
for (int j = i + i; j < limit; j += i)
{
radicals[j].rad *= i;
}
}
}
Radical[] sortedRadicals = new Radical[limit];
Array.Copy(radicals, 1, sortedRadicals, 0, limit);
Array.Sort(sortedRadicals);
for (long c = 3; c <= limit; c++)
{
long radc = radicals[c].rad;
long chalf = c / 2;
foreach (var a in sortedRadicals)
{
if (a.rad * radicals[c].rad > chalf)
{
break;
}
if (a.number >= chalf)
{
continue;
}
long b = c - a.number;
if (a.rad * radicals[b].rad * radc < c && GCD(a.rad, radicals[b].rad) == 1)
{
result += c;
}
}
}
clock.Stop();
Console.WriteLine("sum of c = {0}", result);
Console.WriteLine("Solution took {0} ms", clock.Elapsed.TotalMilliseconds);
}
public void CalculateTest()
{
var calculator = new Radical();
var testresult = calculator.Calculate(124);
var result = Math.Sqrt(124);
Assert.AreEqual(1, 1);
}
public void Dispose()
{
_deferredLoggingEnabled--;
if (_deferredLoggingEnabled == 0)
{
Radical.CommitLog();
}
}
static void Main(string[] args)
{
IOperation operation = new Radical(16, 2);
ICalculator calculator = new ClassLibrary.Calculator(operation);
Console.WriteLine(calculator.CallOperation());
Console.ReadKey(true);
}
public void Dispose()
{
Radical.LogNow("{0} - {1:0.000}", new object[]
{
this._caption,
(DateTime.Now - this._start).TotalSeconds
});
}
public IEnumerator Load()
{
var t = DateTime.Now;
LevelSerializer.LoadSavedLevelFromFile("DROD RPG Savefile.txt");
Radical.CommitLog();
Debug.Log(string.Format("{0:0.000}", (DateTime.Now - t).TotalSeconds));
yield return(new WaitForSeconds(0));
}
private static void TestRadicalHashing()
{
Random rand = new Random();
List <Point> p = new List <Point>();
DateTime now = DateTime.Now;
int randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
p.Add(new Point(1, 1, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
p.Add(new Point(2, 2, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
p.Add(new Point(4, 2, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
p.Add(new Point(5, 3, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
p.Add(new Point(6, 2, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
p.Add(new Point(6, 3, new DateTime(now.Ticks - randNext)));
List <Point> q = new List <Point>();
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
q.Add(new Point(2, 4, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
q.Add(new Point(3, 5, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
q.Add(new Point(5, 5, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
q.Add(new Point(6, 6, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
q.Add(new Point(7, 5, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
q.Add(new Point(7, 6, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
q.Add(new Point(8, 7, new DateTime(now.Ticks - randNext)));
randNext = rand.Next((int)Math.Pow(10, 4), (int)Math.Pow(10, 5));
q.Add(new Point(9, 8, new DateTime(now.Ticks - randNext)));
Stroke s = new Stroke(p);
Stroke s2 = new Stroke(p);
Stroke r = new Stroke(q);
List <Stroke> strokelist = new List <Stroke>();
strokelist.Add(s);
strokelist.Add(s2);
strokelist.Add(r);
Radical rad = new Radical(strokelist);
BinaryWriter bw = new BinaryWriter(new FileStream("test", FileMode.Create, FileAccess.Write, FileShare.None));
bw.Write(rad.Hash(true));
bw.Close();
}
public void Start()
{
var primeList = new PrimeList();
var primeDecomposition = new PrimeDecomposition(primeList);
var radical = new Radical(primeDecomposition);
_abc = new Abc(radical);
Calc();
}
public void CGCalculatorTest()
{
// Test cases taken from here:
// https://en.wikipedia.org/wiki/Table_of_Clebsch%E2%80%93Gordan_coefficients
// The cases are formatted as:
// Items 1-6: j1, j2, m, j, m1, m2
// Item 7: Expected result (in radical form)
var testCases = new List <Tuple <Rational, Rational, Rational, Rational, Rational, Rational, Radical> >()
{
new Tuple <Rational, Rational, Rational, Rational, Rational, Rational, Radical>(
(Rational)1 / 2, (Rational)1 / 2, 1, 1, (Rational)1 / 2, (Rational)1 / 2,
Radical.One),
new Tuple <Rational, Rational, Rational, Rational, Rational, Rational, Radical>(
(Rational)1 / 2, (Rational)1 / 2, -1, 1, -(Rational)1 / 2, (Rational)(-1) / 2,
Radical.One),
new Tuple <Rational, Rational, Rational, Rational, Rational, Rational, Radical>(
(Rational)1 / 2, (Rational)1 / 2, 0, 1, (Rational)1 / 2, (Rational)(-1) / 2,
Radical.Sqrt((Rational)1 / 2)),
new Tuple <Rational, Rational, Rational, Rational, Rational, Rational, Radical>(
(Rational)1 / 2, (Rational)1 / 2, 0, 1, (Rational)(-1) / 2, (Rational)1 / 2,
Radical.Sqrt((Rational)1 / 2)),
new Tuple <Rational, Rational, Rational, Rational, Rational, Rational, Radical>(
(Rational)1 / 2, (Rational)1 / 2, 0, 0, (Rational)1 / 2, (Rational)(-1) / 2,
Radical.Sqrt((Rational)1 / 2)),
new Tuple <Rational, Rational, Rational, Rational, Rational, Rational, Radical>(
(Rational)1 / 2, (Rational)1 / 2, 0, 0, (Rational)(-1) / 2, (Rational)1 / 2,
-Radical.Sqrt((Rational)1 / 2)),
new Tuple <Rational, Rational, Rational, Rational, Rational, Rational, Radical>(
(Rational)5 / 2, 2, (Rational)1 / 2, (Rational)7 / 2, (Rational)3 / 2, -1,
Radical.Sqrt((Rational)121 / 315)),
new Tuple <Rational, Rational, Rational, Rational, Rational, Rational, Radical>(
(Rational)5 / 2, 2, (Rational)1 / 2, (Rational)3 / 2, (Rational)(-3) / 2, 2,
-Radical.Sqrt((Rational)32 / 105)),
new Tuple <Rational, Rational, Rational, Rational, Rational, Rational, Radical>(
(Rational)5 / 2, (Rational)5 / 2, 0, 4, (Rational)(-3) / 2, (Rational)3 / 2,
-Radical.Sqrt((Rational)9 / 28)),
};
foreach (var testCase in testCases)
{
var j1 = testCase.Item1;
var j2 = testCase.Item2;
var m = testCase.Item3;
var j = testCase.Item4;
var m1 = testCase.Item5;
var m2 = testCase.Item6;
var expected = testCase.Item7;
CBScenario scenario = new CBScenario(j1: j1, j2: j2, j: j, m: m);
scenario.InitializeGrid();
scenario.CalculateRawCoefficients();
scenario.NormalizeCoefficients();
var actual = scenario.grid[new Tuple <Rational, Rational>(m1, m2)];
var isEqual = expected == actual.normalizedCoefficient;
Assert.True(isEqual);
}
}
public override object Load(object[] data, object instance)
{
#if US_LOGGING
Radical.Log("Vector3: {0},{1},{2}", data [0], data [1], data [2]);
#endif
return(new UnitySerializer.DeferredSetter(d => {
return new Vector3((float)data [0], (float)data [1], (float)data [2]);
}
));
}
public static Polynomial Divide(Polynomial left, Radical right)
{
var terms = new PolynomialTerm[left.Terms.Length];
for (int i = 0; i < left.Terms.Length; i++)
{
terms[i] = new PolynomialTerm(left.Terms[i].Coefficient / right, left.Terms[i].Degree);
}
return(new Polynomial(terms));
}
public IHttpActionResult Post(Radical radical)
{
if (!ModelState.IsValid) {
return BadRequest(this.ModelState);
}
_repo.SaveRad(radical);
return Created("", radical);
}
public double Execute_CalculateNumbersRadical_ReturnsThatRealEqualsToExpected(double first, double second)
{
//Arrange
IOperation operation = new Radical(first, second);
//Act
var result = operation.Execute();
//Assert
return(result);
}
public async Task <Radical> GetRadicalByIdAsync(int id)
{
Radical radical =
await _context.Radicals
.Include(r => r.KanjiWithReadingAndWordsRadicals)
.Include(r => r.KanjiWithReadingRadicals)
.Include(r => r.KanjiWithWordsRadicals)
.FirstOrDefaultAsync(r => r.Id == id);
return(radical);
}
public static RadicalModel Create(Radical entity)
{
return(new RadicalModel
{
Id = entity.Id,
Word = entity.Word,
HanViet = entity.HanViet,
Meaning = entity.Meaning,
Stroke = entity.Stroke,
});
}
public IHttpActionResult Post(Radical radical)
{
if (!ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
_repo.SaveRad(radical);
return(Created("", radical));
}
public void Bruteforce2()
{
Stopwatch clock = Stopwatch.StartNew();
long result = 0;
long limit = 120000;
Radical[] radicals = new Radical[limit + 1];
for (int i = 0; i < radicals.Length; i++)
{
radicals[i] = new Radical(1, i);
}
for (int i = 2; i <= limit; i++)
{
if (radicals[i].rad == 1)
{
radicals[i].rad = i;
for (int j = i + i; j < limit; j += i)
{
radicals[j].rad *= i;
}
}
}
Radical[] sortedRadicals = new Radical[limit];
Array.Copy(radicals, 1, sortedRadicals, 0, limit);
Array.Sort(sortedRadicals);
for (long c = 3; c <= limit; c++)
{
long radc = radicals[c].rad;
long chalf = c / 2;
foreach (var a in sortedRadicals)
{
if (a.rad * radicals[c].rad > chalf) break;
if (a.number >= chalf) continue;
long b = c - a.number;
if (a.rad * radicals[b].rad * radc < c && GCD(a.rad, radicals[b].rad) == 1)
result += c;
}
}
clock.Stop();
Console.WriteLine("sum of c = {0}", result);
Console.WriteLine("Solution took {0} ms", clock.Elapsed.TotalMilliseconds);
}
//var categories = (from m in _db.Categories select m).ToList();
// return categories;
// Character.Where(p => p.Id == id).FirstOrDefault();
public void SaveRad(Radical radToSave)
{
if (radToSave.Id == 0) {
_db.Radicals.Add(radToSave);
_db.SaveChanges();
} else {
var original = this.Find(radToSave.Id);
original.Symbol = radToSave.Symbol;
original.Pinyin = radToSave.Pinyin;
original.Meaning = radToSave.Meaning;
original.StrokesNum = radToSave.StrokesNum;
_db.SaveChanges();
}
}
public void Bruteforce()
{
Stopwatch clock = Stopwatch.StartNew();
int target = 10000;
int limit = 100000 + 1;
Radical[] radicals = new Radical[limit];
for (int i = 0; i < radicals.Length; i++)
{
radicals[i] = new Radical(1, i);
}
for (int i = 2; i < limit; i++)
{
if (radicals[i].rad == 1)
{
radicals[i].rad = i;
for (int j = i + i; j < limit; j += i)
{
radicals[j].rad *= i;
}
}
}
Array.Sort(radicals);
//for (int i = 0; i < limit-1; i++) {
// Console.WriteLine(radicals[i].number + " " + radicals[i].rad + " " + (i + 1));
//}
clock.Stop();
Console.WriteLine("E({1}) = {0}", radicals[target].number, target);
Console.WriteLine("Solution took {0} ms", clock.Elapsed.TotalMilliseconds);
}
