public static BigInt operator *(BigInt V1, BigInt V2) // v1 * v2
{
V1.DeleteNuls(); V2.DeleteNuls();
var result = new BigInt();
result.EqualizeTheDigits(V1.number.Count + V2.number.Count);
V1.number.Reverse(); V2.number.Reverse();
for (var i = 0; i < V1.number.Count; ++i)
{
for (int j = 0, carry = 0; j < V2.number.Count || carry > 0; ++j)
{
var cur = result.number[i + j] + V1.number[i] * (j < V2.number.Count ? V2.number[j] : 0) + carry;
result.number[i + j] = cur % 10;
carry = cur / 10;
}
}
while (result.number.Count > 1 && result.number.Last() == 0)
{
result.number.RemoveAt(result.number.Count - 1);
}
result.sign = V1.sign == V2.sign ? '+' : '-';
V1.number.Reverse(); V2.number.Reverse();
result.number.Reverse();
result.DeleteNuls();
return(result);
}
/// <summary>
/// Compare two triangles and return true if equal
/// </summary>
/// <param name="tri">the other triangles to compare with</param>
/// <returns>true if the two triangles equals, false otherwise</returns>
public bool Equals(Triangle2DF tri)
{
return
((V0.Equals(tri.V0) || V0.Equals(tri.V1) || V0.Equals(tri.V2)) &&
(V1.Equals(tri.V0) || V1.Equals(tri.V1) || V1.Equals(tri.V2)) &&
(V2.Equals(tri.V0) || V2.Equals(tri.V1) || V2.Equals(tri.V2)));
}
public ActionResult Edit(List <Location> locations, int id)
{
if (ModelState.IsValid)
{
Menu menu = db.Menus.Find(id);
if (menu == null)
{
return(HttpNotFound());
}
//set serialized data into menu
menu.Locations = Composer.V1.SerializeLocations(locations);
//save menu
db.Entry(menu).State = EntityState.Modified;
db.SaveChanges();
//re-compose the menu
V1 composer = new V1(menu);
composer.CreateMenu();
return(RedirectToAction("Edit", "Menu", new { id = id }));
}
return(View(locations));
}
public List <AttributeValue> SortedValues(Func <AttributeValue[], AttributeValue> Discriminator)
{
List <AttributeValue> R = new List <AttributeValue>();
AttributeValue[] Current = new AttributeValue[_Values.Length];
for (int i = 0; i < _Values[0].Count; ++i)
{
for (int j = 0; j < _Values.Length; ++j)
{
Current[j] = _Values[j][i];
}
R.Add(Discriminator.Invoke(Current));
}
R.Sort(delegate(AttributeValue V1, AttributeValue V2) { return(V1.CompareTo(V2)); });
List <AttributeValue> N = new List <AttributeValue>();
foreach (AttributeValue V in R)
{
if (N.Count == 0 || V.CompareTo(N[N.Count - 1]) != 0)
{
N.Add(V);
}
}
return(N);
}
public void Versioning()
{
var v1 = MessagePackSerializer.Serialize(new V1 {
ABCDEFG1 = 10, ABCDEFG3 = 99
}, Resolvers.ContractlessStandardResolver.Options);
var v2 = MessagePackSerializer.Serialize(new V2 {
ABCDEFG1 = 350, ABCDEFG2 = 34, ABCDEFG3 = 500
}, Resolvers.ContractlessStandardResolver.Options);
V1 v1_1 = MessagePackSerializer.Deserialize <V1>(v1, Resolvers.ContractlessStandardResolver.Options);
V1 v1_2 = MessagePackSerializer.Deserialize <V1>(v2, Resolvers.ContractlessStandardResolver.Options);
V2 v2_1 = MessagePackSerializer.Deserialize <V2>(v1, Resolvers.ContractlessStandardResolver.Options);
V2 v2_2 = MessagePackSerializer.Deserialize <V2>(v2, Resolvers.ContractlessStandardResolver.Options);
v1_1.ABCDEFG1.Is(10);
v1_1.ABCDEFG3.Is(99);
v1_2.ABCDEFG1.Is(350);
v1_2.ABCDEFG3.Is(500);
v2_1.ABCDEFG1.Is(10);
v2_1.ABCDEFG2.Is(0);
v2_1.ABCDEFG3.Is(99);
v2_2.ABCDEFG1.Is(350);
v2_2.ABCDEFG2.Is(34);
v2_2.ABCDEFG3.Is(500);
}
public static void SaveToInstructorPage(Class classObj, Instructor instructorObj)
{
V1 composer = new V1(classObj, instructorObj);
// re-compose the instructor page
composer.CreateInstructorPage();
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append('{');
WriteName(sb, "V0");
sb.Append(V0.ToString() + ",");
WriteName(sb, "V1");
sb.Append(V1.ToString() + ",");
WriteName(sb, "V2");
sb.Append(V2.ToString() + ",");
WriteName(sb, "V3");
sb.Append(V3.ToString() + ",");
WriteName(sb, "V4");
sb.Append(V4.ToString() + ",");
WriteName(sb, "V5");
sb.Append(V5.ToString() + ",");
WriteName(sb, "V6");
sb.Append(V6.ToString() + ",");
WriteName(sb, "V7");
sb.Append(V7.ToString() + ",");
WriteName(sb, "V8");
sb.Append(V8.ToString() + ",");
WriteName(sb, "V9");
sb.Append(V9.ToString() + ",");
sb.Length--;
sb.Append('}');
return(sb.ToString());
}
public Triangle3D Translate(Point3D amount)
{
V1.Translate(amount);
V2.Translate(amount);
V3.Translate(amount);
return(this);
}
public void Read(BinaryReader reader, int length)
{
V1.Read(reader, Constants.SIZE_VECTOR4);
V2.Read(reader, Constants.SIZE_VECTOR4);
V3.Read(reader, Constants.SIZE_VECTOR4);
V4.Read(reader, Constants.SIZE_VECTOR4);
}
public Triangle3D Scale(Point3D amount)
{
V1.Scale(amount);
V2.Scale(amount);
V3.Scale(amount);
return(this);
}
/// <summary>
/// Creates a round 1 (zero-knowledge proof) DTO to send to the partner participant.
/// </summary>
public ECJpakeRound1 CreateRound1ToSend()
{
Contract.Requires(ProtocolState < State.Round1Created, "Round 1 payload already created.");
BigInteger x1 = BigInteger.CreateRandomInRange(BigInteger.One, _domain.N.Subtract(BigInteger.One),
EntropySupply);
_x2 = BigInteger.CreateRandomInRange(BigInteger.One, _domain.N.Subtract(BigInteger.One), EntropySupply);
_gx1 = BasePointMultiplier.Multiply(_domain.G, x1);
_gx2 = BasePointMultiplier.Multiply(_domain.G, _x2);
ECPoint V1, V2;
BigInteger r1, r2;
CreateZeroKnowledgeProof(_domain.G, x1, _gx1, ParticipantId, out V1, out r1);
CreateZeroKnowledgeProof(_domain.G, _x2, _gx2, ParticipantId, out V2, out r2);
var dto = new ECJpakeRound1 {
ParticipantId = ParticipantId,
GX1 = _gx1.GetEncoded(),
X1V = V1.GetEncoded(),
X1R = r1.ToByteArray(),
GX2 = _gx2.GetEncoded(),
X2V = V2.GetEncoded(),
X2R = r2.ToByteArray()
};
ProtocolState = State.Round1Created;
return(dto);
}
private List <Pair <AttributeValue, double> > Proportions(Func <AttributeValue[], AttributeValue> Discriminator)
{
List <Pair <AttributeValue, double> > P = new List <Pair <AttributeValue, double> >();
List <AttributeValue> V = new List <AttributeValue>();
AttributeValue[] Current = new AttributeValue[_Values.Length];
for (int i = 0; i < _Values[0].Count; ++i)
{
for (int j = 0; j < _Values.Length; ++j)
{
Current[j] = _Values[j][i];
}
V.Add(Discriminator.Invoke(Current));
}
V.Sort(delegate(AttributeValue V1, AttributeValue V2) { return(V1.CompareTo(V2)); });
AttributeValue C = null;
foreach (AttributeValue v in V)
{
if (C == null || C.CompareTo(v) != 0)
{
C = v;
P.Add(new Pair <AttributeValue, double>(v, 1d / V.Count));
}
else
{
P[P.Count - 1].Second += 1d / V.Count;
}
}
return(P);
}
//non-blocking emailer
public static void NotifySubscribers(Class classObj)
{
#if !NoEmail
new Thread(() =>
{
if (classObj != null)
{
IList <Subscriber> currentSubscribers = V1.DeserializeSubscribers(classObj.Subscribers);
if (currentSubscribers != null)
{
foreach (Subscriber subscriber in currentSubscribers)
{
//Send email
try //TODO: remove try/catch when using real SMTP server in production
{
//synchronous
//new MailController().SendClassUpdateEmail(subscriber.Email, classObj.Name, classObj.ID, classObj.Url).Deliver();
//asynchronous (but using DeliverAync doesn't work w/ a real SMTP server for some reason)
new MailControllerAsync().SendClassUpdateEmailAsync(subscriber.Email, classObj.Name, classObj.ID, classObj.Url).Deliver();
}
catch (Exception e)
{
string hi = e.Message;
}
}
}
}
}).Start();
#endif
}
public void WriteTo(TextWriter writer)
{
V1.WriteTo(writer);
writer.Write(" ");
V2.WriteTo(writer);
writer.Write(" ");
V3.WriteTo(writer);
writer.Write(" ");
writer.Write(TextureName);
writer.Write(" ");
writer.Write(XOffset);
writer.Write(" ");
writer.Write(YOffset);
writer.Write(" ");
writer.Write(Rotation);
writer.Write(" ");
writer.Write(XScale.ToString("F6"));
writer.Write(" ");
writer.Write(YScale.ToString("F6"));
writer.Write(" ");
writer.Write(Flag1);
writer.Write(" ");
writer.Write(Flag2);
writer.Write(" ");
writer.Write(Flag3);
writer.WriteLine();
}
public ActionResult Index(int id = 0)
{
Class classObj;
if (!Utilities.GetClassObjFromId(db, id, out classObj))
{
return(HttpNotFound());
}
Instructor instructorObj;
if (!Utilities.GetInstructorObjFromEmail(db, classObj.Instructor, out instructorObj))
{
return(HttpNotFound());
}
EditorViewModel editorViewData = new EditorViewModel();
//data
editorViewData.classObj = classObj;
editorViewData.instructorObj = instructorObj;
editorViewData.announcements = V1.DeserializeAnnouncements(classObj.Announcements);
editorViewData.assignments = V1.DeserializeAssignments(classObj.Assignments);
editorViewData.subscribers = V1.DeserializeSubscribers(classObj.Subscribers);
editorViewData.fullUrl = Utilities.GetFullUrl(classObj.Url);
//labels
editorViewData.AnnouncementsLbl = Constants.AnnouncementsLbl;
editorViewData.AssignmentsLbl = Constants.AssignmentsLbl;
editorViewData.InstructorLbl = Constants.InstructorLbl;
return(View(editorViewData));
}
public Vector3d GetNormal()
{
Vector3d vector = V1.Subtract(V2);
Vector3d vector2 = V1.Subtract(V3);
return(vector.CrossProduct(vector2));
}
public bool CircumcircleContainsVertex(Vector v)
{
double ab = V1.norm2();
double cd = V2.norm2();
double ef = V3.norm2();
double ax = V1.X;
double ay = V1.Y;
double bx = V2.X;
double by = V2.Y;
double cx = V3.X;
double cy = V3.Y;
double circum_x = (ab * (cy - by) + cd * (ay - cy) + ef * (by - ay)) / (ax * (cy - by) + bx * (ay - cy) + cx * (by - ay));
double circum_y = (ab * (cx - bx) + cd * (ax - cx) + ef * (bx - ax)) / (ay * (cx - bx) + by * (ax - cx) + cy * (bx - ax));
Vector center = new Vector {
X = circum_x * 0.5, Y = circum_y * 0.5
};
double radius = V1.dist2(center);
double dist = v.dist2(center);
return(dist <= radius);
}
public void Write(BinaryWriter writer)
{
V1.Write(writer);
V2.Write(writer);
V3.Write(writer);
V4.Write(writer);
}
public bool Equals(VertexPair other)
{
if (V1.Equals(other.V1) && V2.Equals(other.V2))
{
return(true);
}
return(false);
}
public static void SaveToClassDartAndInstructorPage(Class classObj, Instructor instructorObj)
{
V1 composer = new V1(classObj, instructorObj);
// re-compose the classdart page
composer.CreateClassDart();
composer.CreateInstructorPage();
}
public Triangle Multiply(Matrix4x4 trans)
{
var p1 = V1.Multiply(trans);
var p2 = V2.Multiply(trans);
var p3 = V3.Multiply(trans);
return(new Triangle(p1, p2, p3));
}
public void ValueObjectToString()
{
var v1 = new V1("a").ToString();
var v2 = new Address("a", "b", "c", "d", "f").ToString();
Assert.Equal("a", v1);
Assert.Equal("Address [Street: \"a\" | City: \"b\" | State: \"c\" | Country: \"d\" | ZipCode: \"f\"]", v2);
}
public void Version1_Practise()
{
var decimalPalindrome = new[] { 5, 8, 5 };
var binaryPalindrome = new[] { 1, 0, 0, 1, 0, 0, 1, 0, 0, 1 };
V1.IsPalindromic(decimalPalindrome).ShouldBeTrue();
V1.IsPalindromic(binaryPalindrome).ShouldBeTrue();
}
public void Version1_PandigitalNumbers_t()
{
var t1 = new[] { 0, 1 }.DigitsToNumber();
var t2 = new[] { 1, 0 }.DigitsToNumber();
var t3 = new[] { 1, 2 }.DigitsToNumber();
var tt = MiscUtils.GetDigits(10).ToArray();
var ds = V1.DistinctNumbers().Take(100).ToArray();
var ps = V1.GetMultipliers(new[] { 3, 9 }, 9).Select(x => x.DigitsToNumber()).OrderBy(x => x).ToArray();
}
/// <summary>
/// 转换为字符串
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("V1:" + V1.ToString() + ";");
stringBuilder.Append("V2:" + V2.ToString() + ";");
stringBuilder.Append("V3:" + V3.ToString());
return(stringBuilder.ToString());
}
/// <summary>
/// <para>Сравнение двух объектов, путем сравнения значений каждого поля объета.</para>
/// <para>Проверяются только public поля.</para>
/// </summary>
public static bool IsFieldsEquals(this object self, object obj, bool ignoreNull = false)
{
if (self == null && obj == null)
{
return(true);
}
if (self == null || obj == null)
{
return(false);
}
var res = self.Equals(obj);
if (self.IsPrimitiveType() || obj.IsPrimitiveType())
{
return(res);
}
if (!res)
{
res = true;
Type T1 = self.GetType();
Type T2 = obj.GetType();
var PL1 = T1.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
var PL2 = T2.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
object V1;
object V2;
foreach (var P1 in PL1)
{
V1 = P1.GetValue(self);
if (ignoreNull && V1 == null)
{
continue;
}
if (T1 == T2)
{
V2 = P1.GetValue(obj);
}
else
{
V2 = V1;
foreach (var P2 in PL2)
{
if (P2.Name == P1.Name)
{
V2 = P2.GetValue(obj);
break;
}
}
}
res = V1.IsFieldsEquals(V2);
if (!res)
{
break;
}
}
}
return(res);
}
public override int GetHashCode()
{
int hash_1 = V1.GetHashCode();
int hash_2 = V2.GetHashCode();
int hash_3 = V3.GetHashCode();
int hash_4 = V4.GetHashCode();
return(hash_1 ^ hash_2 ^ hash_3 ^ hash_4);
}
public void Version1_Practise()
{
V1.SatisfiesConjecture(9, new SortedSet <long>(), new SortedSet <long>()).ShouldBeTrue();
V1.SatisfiesConjecture(15, new SortedSet <long>(), new SortedSet <long>()).ShouldBeTrue();
V1.SatisfiesConjecture(21, new SortedSet <long>(), new SortedSet <long>()).ShouldBeTrue();
V1.SatisfiesConjecture(25, new SortedSet <long>(), new SortedSet <long>()).ShouldBeTrue();
V1.SatisfiesConjecture(27, new SortedSet <long>(), new SortedSet <long>()).ShouldBeTrue();
V1.SatisfiesConjecture(33, new SortedSet <long>(), new SortedSet <long>()).ShouldBeTrue();
}
public void Dispose()
{
if (Instance is IDisposable V1)
{
V1.Dispose();
}
Dispatcher?.InvokeShutdown();
}
/// <summary>Collecting all required parameters to execute a Mapper.map call.</summary>
/// <remarks>
/// Collecting all required parameters to execute a Mapper.map call.
/// <p>
/// </remarks>
/// <param name="key"/>
/// <param name="value"/>
/// <param name="output"/>
/// <param name="reporter"/>
public MapperInvokeRunable(MultithreadedMapRunner <K1, V1, K2, V2> _enclosing, K1
key, V1 value, OutputCollector <K2, V2> output, Reporter reporter)
{
this._enclosing = _enclosing;
this.key = key;
this.value = value;
this.output = output;
this.reporter = reporter;
}
/// <summary>
/// Erstellt ein neues Element mit Bild aus einer alten Konfiguration.
/// </summary>
/// <param name="alteDarstellung">Die ursprüngliche Konfiguration.</param>
internal ElementMitBildSequenz( V1.BildElement alteDarstellung )
: base(alteDarstellung)
{
// Alles übernehmen
Animation = ElementBewegung.Erzeugen( alteDarstellung.Bewegung );
BilderProSekunde = alteDarstellung.BilderProSekunde;
Bilder = alteDarstellung.Bilder;
Ebene = alteDarstellung.Ebene;
// Punkte auswerten
var punkte = alteDarstellung.Wert;
if (punkte != 0)
Kollisionsregeln.Insert( 0, new Punkteregel { ArtDerKollision = KollisionsArten.VomSpielerGetroffen, Punkte = punkte } );
}
/// <summary>
/// Erstellt eine Bewegung aus einer älteren Konfiguration.
/// </summary>
/// <param name="alteDarstellung">Die ursprüngliche Konfiguration.</param>
/// <returns>Die neue Repräsentation der Bewegung des Elementes.</returns>
public static ElementBewegung Erzeugen( V1.Bewegung alteDarstellung )
{
// Das Element steht ruhig da
if (alteDarstellung == null)
return null;
// Einfaches hoch und runter
var hüpfen = alteDarstellung as V1.Huepfen;
if (hüpfen != null)
return new VertikaleBewegung( hüpfen );
// Im Moment nicht unterstützt
return null;
}
/// <summary>
/// Erstellt eine neue Spielfigur aus einer alten Konfiguration.
/// </summary>
/// <param name="alteDarstellung">Die ursprüngliche Darstellung der Spielfigur.</param>
public Spielfigur( V1.Figur alteDarstellung )
{
// Prüfen
if (alteDarstellung == null)
throw new ArgumentNullException( "alteDarstellung" );
// Alles übernehmen
MaximaleGeschwindigkeit = alteDarstellung.MaximaleGeschwindigkeit;
SpruengeNacheinander = alteDarstellung.SpruengeNacheinander;
BilderProSekunde = alteDarstellung.BilderProSekunde;
BilderNachRechts = alteDarstellung.BilderNachRechts;
BilderNachLinks = alteDarstellung.BilderNachLinks;
BilderImSprung = alteDarstellung.BilderImSprung;
SprungStaerke = alteDarstellung.SprungStaerke;
BilderRuhend = alteDarstellung.BilderRuhend;
Name = alteDarstellung.Name;
}
/// <summary>
/// Erstellt ein neues Spielfeld aus einer alten Konfiguration.
/// </summary>
/// <param name="alteDarstellung">Die alte Konfiguration.</param>
public Spielfeld( V1.Spielfeld alteDarstellung )
{
// Prüfen
if (alteDarstellung == null)
throw new ArgumentNullException( "alteDarstellung" );
// Alles übernehmen
MaximaleGeschwindigkeit = alteDarstellung.MaximaleGeschwindigkeit;
MaximaleSprungStaerke = alteDarstellung.MaximaleSprungStaerke;
InitialeLebensenergie = alteDarstellung.InitialeLebensenergie;
InitialePosition = alteDarstellung.InitialePosition;
BildVerloren = alteDarstellung.BildVerloren;
BildGewonnen = alteDarstellung.BildGewonnen;
Beschreibung = alteDarstellung.Name;
Kennung = alteDarstellung.Kennung;
Bild = alteDarstellung.Bild;
// Elemente wandeln
Elemente = alteDarstellung.Elemente.Select( Element.Erzeugen ).ToList();
}
/// <summary>
/// Rekonstruiert ein Element aus einer älteren Konfiguration.
/// </summary>
/// <param name="alteDarstellung">Die ursprüngliche Konfiguration.</param>
protected Element( V1.Element alteDarstellung )
{
// Abschliessen
Kollisionsregeln = new List<Kollisionsregel>();
// Alles kopieren
Breite = alteDarstellung.Width;
Hoehe = alteDarstellung.Height;
Melodie = alteDarstellung.Melodie;
VertikalePosition = alteDarstellung.Bottom;
HorizontalePosition = alteDarstellung.Left;
// Lebensenergie auswerten
var lebensenergie = alteDarstellung.Lebensenergie;
if (lebensenergie != 0)
{
// Regel anlegen
var energieRegel = new Energieregel { Lebensenergie = lebensenergie };
// Konfiguration der Regel abschliessen
if (lebensenergie > 0)
energieRegel.ArtDerKollision = KollisionsArten.VomSpielerGetroffen;
else if (alteDarstellung.ElementArt == V1.ElementArt.Beweglich)
energieRegel.ArtDerKollision = KollisionsArten.VomSpielerSeitlichGetroffen;
else
energieRegel.ArtDerKollision = KollisionsArten.VomSpielerGetroffen;
// Regel eintragen
Kollisionsregeln.Add( energieRegel );
}
// Ausgang anmelden
if (alteDarstellung.ElementArt == V1.ElementArt.Ausgang)
Kollisionsregeln.Add( new Enderegel { Gewonnen = true, ArtDerKollision = KollisionsArten.VomSpielerGetroffen } );
// Element ausblenden - das muss immer die letzte Regel sein
if (alteDarstellung.ElementArt == V1.ElementArt.Beweglich)
Kollisionsregeln.Add( new Verschwinderegel { ArtDerKollision = KollisionsArten.VomSpielerGetroffen } );
}
/// <summary>
/// Rekonstruiert ein Element aus einer älteren Konfiguration.
/// </summary>
/// <param name="alteDarstellung">Die ursprüngliche Konfiguration.</param>
/// <returns>Das gewünschte Element.</returns>
public static Element Erzeugen( V1.Element alteDarstellung )
{
// Prüfen
if (alteDarstellung == null)
throw new ArgumentNullException( "alteDarstellung" );
// Element mit Bild
var elementMitBild = alteDarstellung as V1.BildElement;
if (elementMitBild != null)
return new ElementMitBildSequenz( elementMitBild );
// Wandeln
return new Element( alteDarstellung );
}
/// <summary>
/// Erstellt eine neue Beschreibung aus einer älteren Konfiguration.
/// </summary>
/// <param name="alteDarstellung">Die ursprüngliche Konfiguration.</param>
internal VertikaleBewegung( V1.Huepfen alteDarstellung )
{
// Alles übernehmen
Sprunghöhe = alteDarstellung.SprungHoehe;
Sprungzeit = alteDarstellung.SprungZeit;
}
internal Trigger(ITaskTrigger trigger, V1.TaskTriggerType type)
{
v1Trigger = trigger;
v1TriggerData = trigger.GetTrigger();
v1TriggerData.Type = type;
ttype = ConvertFromV1TriggerType(type);
}
internal static TaskTriggerType ConvertFromV1TriggerType(V1.TaskTriggerType v1Type)
{
var v2tt = (int)v1Type + 1;
if (v2tt > 6) {
v2tt++;
}
return (TaskTriggerType)v2tt;
}
internal static Trigger CreateTrigger(ITaskTrigger trigger, V1.TaskTriggerType triggerType)
{
Trigger t = null;
switch (triggerType) {
case V1.TaskTriggerType.RunOnce:
t = new TimeTrigger(trigger);
break;
case V1.TaskTriggerType.RunDaily:
t = new DailyTrigger(trigger);
break;
case V1.TaskTriggerType.RunWeekly:
t = new WeeklyTrigger(trigger);
break;
case V1.TaskTriggerType.RunMonthly:
t = new MonthlyTrigger(trigger);
break;
case V1.TaskTriggerType.RunMonthlyDOW:
t = new MonthlyDOWTrigger(trigger);
break;
case V1.TaskTriggerType.OnIdle:
t = new IdleTrigger(trigger);
break;
case V1.TaskTriggerType.OnSystemStart:
t = new BootTrigger(trigger);
break;
case V1.TaskTriggerType.OnLogon:
t = new LogonTrigger(trigger);
break;
default:
break;
}
//if (t != null) t.ttype = triggerType;
return t;
}
/// <summary>
/// Erzeugt ein neues Spiel aus einer alten Konfiguration.
/// </summary>
/// <param name="alteDarstellung">Die urspräungliche Darstellung der Konfiguration.</param>
public Spiel( V1.Spiel alteDarstellung )
{
// Alles übernehmen
SichtfensterBreite = alteDarstellung.SichtfensterBreite;
SichtfensterHoehe = alteDarstellung.SichtfensterHoehe;
}
/// <summary>
/// 只能对完整版数据进行转换
/// </summary>
/// <param name="oldTick"></param>
/// <returns></returns>
public static V2.PbTick Converter(V1.PbTick oldTick)
{
if (oldTick == null)
return null;
V2.PbTick tick = new V2.PbTick();
tick.Config = new V2.ConfigInfo().Default();
tick.Config.Version = oldTick.Config.Version;
tick.Config.AveragePriceMultiplier = oldTick.Config.AveragePriceMultiplier;
tick.Config.ContractMultiplier = oldTick.Config.ContractMultiplier;
tick.Config.SettlementPriceMultiplier = oldTick.Config.SettlementPriceMultiplier;
tick.Config.TickSize = oldTick.Config.TickSize;
tick.Config.TickSizeMultiplier = oldTick.Config.TickSizeMultiplier;
tick.Config.Time_ssf_Diff = oldTick.Config.Time_ssf_Diff;
tick.DepthList = new List<V2.DepthItem>();
V1.DepthTick next = oldTick.Depth1_3;
if (next != null)
{
if (next.AskSize1 != 0)
tick.AskPrice1 = next.AskPrice1;
else
tick.AskPrice1 = next.BidPrice1 + 1;
}
while (next != null)
{
if (next.AskSize1 != 0)
tick.DepthList.Add(new V2.DepthItem(next.AskPrice1, next.AskSize1, next.AskCount1));
if (next.AskSize2 != 0)
tick.DepthList.Add(new V2.DepthItem(next.AskPrice2, next.AskSize2, next.AskCount2));
if (next.AskSize3 != 0)
tick.DepthList.Add(new V2.DepthItem(next.AskPrice3, next.AskSize3, next.AskCount3));
if (next.BidSize1 != 0)
tick.DepthList.Insert(0, new V2.DepthItem(next.BidPrice1, next.BidSize1, next.BidCount1));
if (next.BidSize2 != 0)
tick.DepthList.Insert(0, new V2.DepthItem(next.BidPrice2, next.BidSize2, next.BidCount2));
if (next.BidSize3 != 0)
tick.DepthList.Insert(0, new V2.DepthItem(next.BidPrice3, next.BidSize3, next.BidCount3));
// 指向下一个
next = next.Next;
}
if(oldTick.Bar != null)
{
tick.Bar = new V2.BarInfo();
tick.Bar.BarSize = oldTick.Bar.BarSize;
tick.Bar.Close = oldTick.Bar.Close;
tick.Bar.High = oldTick.Bar.High;
tick.Bar.Low = oldTick.Bar.Low;
tick.Bar.Open = oldTick.Bar.Open;
}
if (oldTick.Split != null)
{
tick.Split = new V2.StockSplitInfo();
tick.Split.CashDividend = oldTick.Split.CashDividend;
tick.Split.PreClose = oldTick.Split.PreClose;
tick.Split.RightsOffering = oldTick.Split.RightsOffering;
tick.Split.RightsOfferingPrice = oldTick.Split.RightsOfferingPrice;
tick.Split.StockDividend = oldTick.Split.StockDividend;
}
if(oldTick.Static != null)
{
tick.Static = new V2.StaticInfo();
tick.Static.Exchange = oldTick.Static.Exchange;
tick.Static.LowerLimitPrice = oldTick.Static.LowerLimitPrice;
tick.Static.SettlementPrice = oldTick.Static.SettlementPrice;
tick.Static.Symbol = oldTick.Static.Exchange;
tick.Static.UpperLimitPrice = oldTick.Static.UpperLimitPrice;
}
tick.ActionDay = oldTick.ActionDay;
tick.TradingDay = oldTick.TradingDay;
tick.Time_HHmm = oldTick.Time_HHmm;
tick.Time_____ssf__ = oldTick.Time_____ssf__;
tick.Time________ff = oldTick.Time________ff;
tick.Volume = oldTick.Volume;
tick.Turnover = oldTick.Turnover;
tick.OpenInterest = oldTick.OpenInterest;
tick.LastPrice = oldTick.LastPrice;
tick.AveragePrice = oldTick.AveragePrice;
return tick;
}
