public override int GetHashCode()
{
int hashcode = 157;
unchecked {
if (isset.impl_type)
{
hashcode = (hashcode * 397) + Impl_type.GetHashCode();
}
if (isset.min_val)
{
hashcode = (hashcode * 397) + Min_val.GetHashCode();
}
if (isset.bitmap_sz_bits)
{
hashcode = (hashcode * 397) + Bitmap_sz_bits.GetHashCode();
}
if (isset.approximate)
{
hashcode = (hashcode * 397) + Approximate.GetHashCode();
}
if (isset.device_type)
{
hashcode = (hashcode * 397) + Device_type.GetHashCode();
}
if (isset.sub_bitmap_count)
{
hashcode = (hashcode * 397) + Sub_bitmap_count.GetHashCode();
}
}
return(hashcode);
}
static void Main(string[] args)
{
bool isGraphsChecker = IsValidGraphsChecker(args);
bool isComplexityChecker = IsValidComplexityChecker(args);
if (!(isGraphsChecker ^ isComplexityChecker))
{
ShowHelp(args);
return;
}
bool exact = args[0] == "exact";
if (isGraphsChecker)
{
var G = GraphLoader.FromCSV(args[1]);
var H = GraphLoader.FromCSV(args[2]);
var modularGraph = ModularGraph.Create(G, H);
if (exact)
{
var exactResult = new Exact(G, H, modularGraph).Run();
GraphLoader.ToCSV(exactResult, "Examples/exact.csv");
}
else
{
var approximateResult = new Approximate(G, H, modularGraph).Run();
GraphLoader.ToCSV(approximateResult, "Examples/approximate.csv");
}
}
else
{
new ComplexityChecker(args[2], exact).Run();
}
}
private void UpdateMaxCurrentTemperature()
{
if (vessel.mainBody.atmosphereContainsOxygen && vessel.staticPressurekPa > 0)
{
var combinedPresure = vessel.staticPressurekPa + vessel.dynamicPressurekPa * 0.2;
if (combinedPresure > 101.325)
{
var extraPresure = combinedPresure - 101.325;
var ratio = extraPresure / 101.325;
if (ratio <= 1)
{
ratio *= ratio;
}
else
{
ratio = ratio.Sqrt();
}
oxidationModifier = 1 + ratio * 0.1;
}
else
{
oxidationModifier = Approximate.FourthRoot((float)(combinedPresure / 101.325));
}
spaceRadiatorBonus = maxSpaceTempBonus * (1 - (oxidationModifier));
maxCurrentRadiatorTemperature = Math.Min(maxVacuumTemperature, Math.Max(PhysicsGlobals.SpaceTemperature, maxAtmosphereTemperature + spaceRadiatorBonus));
}
else
{
spaceRadiatorBonus = maxSpaceTempBonus;
maxCurrentRadiatorTemperature = maxVacuumTemperature;
}
}
public Rounding(Approximate s, sbyte decimals = 2, byte digit = 5,
double step = 0.1)
{
strategy = s;
this.decimals = validateDecimals(decimals);
this.digit = validateDigit(digit);
this.step = validateStep(step);
}
public void Run(int n)
{
// create unit vector
double[] u = new double[n];
double[] tmp = new double[n];
double[] v = new double[n];
for (int i = 0; i < n; i++)
u[i] = 1.0;
int nthread = Environment.ProcessorCount;
BarrierHandle barrier = new BarrierHandle(nthread);
// objects contain result of each thread
Approximate[] apx = new Approximate[nthread];
// thread handle for waiting/joining
Thread[] threads = new Thread[nthread];
// create thread and hand out tasks
int chunk = n / nthread;
for (int i = 0; i < nthread; i++)
{
int r1 = i * chunk;
int r2 = (i < (nthread - 1)) ? r1 + chunk : n;
apx[i] = new Approximate(u, v, tmp, r1, r2);
apx[i].Barrier = barrier;
threads[i] = new Thread(new ThreadStart(apx[i].Evaluate));
threads[i].Start();
}
// collect results
double vBv = 0, vv = 0;
for (int i = 0; i < nthread; i++)
{
threads[i].Join();
vBv += apx[i].m_vBv;
vv += apx[i].m_vv;
}
var res = Math.Sqrt(vBv / vv);
Console.WriteLine("{0:f9}", res);
}
public static double RunGame(int n)
{
// create unit vector
double[] u = new double[n];
double[] tmp = new double[n];
double[] v = new double[n];
for (int i = 0; i < n; i++)
{
u[i] = 1.0;
}
int nthread = Environment.ProcessorCount;
BarrierHandle barrier = new BarrierHandle(nthread);
// objects contain result of each thread
Approximate[] apx = new Approximate[nthread];
// thread handle for waiting/joining
Thread[] threads = new Thread[nthread];
// create thread and hand out tasks
int chunk = n / nthread;
for (int i = 0; i < nthread; i++)
{
int r1 = i * chunk;
int r2 = (i < (nthread - 1)) ? r1 + chunk : n;
apx[i] = new Approximate(u, v, tmp, r1, r2);
apx[i].Barrier = barrier;
threads[i] = new Thread(new ThreadStart(apx[i].Evaluate));
threads[i].Start();
}
// collect results
double vBv = 0, vv = 0;
for (int i = 0; i < nthread; i++)
{
threads[i].Join();
vBv += apx[i].m_vBv;
vv += apx[i].m_vv;
}
return(Math.Sqrt(vBv / vv));
}
public static double RunGame(int n)
{
// create unit vector
double[] tmp = new double[n];
double[] v = new double[n];
double[] u = Enumerable.Repeat(1.0, n).ToArray();
var nthread = Environment.ProcessorCount;
var tasks = new List <Task <Approximate> >(nthread);
// create thread and hand out tasks
int chunk = n / nthread;
for (int i = 0; i < nthread; i++)
{
int r1 = i * chunk;
int r2 = (i < (nthread - 1)) ? r1 + chunk : n;
tasks.Add(Task.Run(() => {
var apx = new Approximate(u, v, tmp, r1, r2);
apx.Evaluate();
return(apx);
}));
}
Task.WaitAll(tasks.ToArray());
double vBv = 0, vv = 0;
foreach (var task in tasks)
{
var obj = task.Result;
vBv += obj.m_vBv;
vv += obj.m_vv;
}
return(Math.Sqrt(vBv / vv));
}
private static double RunGame(int n)
{
int V_3;
double[] V_0 = new double[n];
double[] V_1 = new double[n];
double[] V_2 = new double[n];
for (V_3 = RemoteConstantLoader.LoadInt32(0x1d); V_3 < n; V_3 += RemoteConstantLoader.LoadInt32(0x1f))
{
V_0[V_3] = RemoteConstantLoader.LoadFloat64(30);
}
int V_4 = Environment.ProcessorCount;
BarrierHandle V_5 = new BarrierHandle(V_4);
Approximate[] V_6 = new Approximate[V_4];
Thread[] V_7 = new Thread[V_4];
int V_8 = n / V_4;
for (V_3 = RemoteConstantLoader.LoadInt32(0x20); V_3 < V_4; V_3 += RemoteConstantLoader.LoadInt32(0x22))
{
int V_9 = V_3 * V_8;
int V_10 = (V_3 < (V_4 - RemoteConstantLoader.LoadInt32(0x21))) ? (V_9 + V_8) : n;
V_6[V_3] = new Approximate(V_0, V_2, V_1, V_9, V_10);
V_6[V_3].Barrier = V_5;
V_7[V_3] = new Thread(new ThreadStart(V_6[V_3].Evaluate));
V_7[V_3].Start();
}
double V_11 = RemoteConstantLoader.LoadFloat64(0x23);
double V_12 = RemoteConstantLoader.LoadFloat64(0x24);
for (V_3 = RemoteConstantLoader.LoadInt32(0x25); V_3 < V_4; V_3 += RemoteConstantLoader.LoadInt32(0x26))
{
V_7[V_3].Join();
V_11 += V_6[V_3].m_vBv;
V_12 += V_6[V_3].m_vv;
}
return(Math.Sqrt(V_11 / V_12));
}
private static double spectralnormGame(int n)
{
double [] u = new double [n];
double [] v = new double [n];
double [] tmp = new double [n];
// create unit vector
for (int i = 0; i < n; i++)
{
u [i] = 1.0;
}
int nthread = Environment.ProcessorCount;
int chunk = n / nthread;
var barrier = new Barrier(nthread);
Approximate [] ap = new Approximate [nthread];
for (int i = 0; i < nthread; i++)
{
int r1 = i * chunk;
int r2 = (i < (nthread - 1)) ? r1 + chunk : n;
ap [i] = new Approximate(u, v, tmp, r1, r2, barrier);
}
double vBv = 0, vv = 0;
for (int i = 0; i < nthread; i++)
{
ap [i].t.Wait();
vBv += ap [i].m_vBv;
vv += ap [i].m_vv;
}
return(Math.Sqrt(vBv / vv));
}
public static IVesselRelayPersistence GetVesselRelayPersistenceForProtoVessel(Vessel vessel)
{
var relayVessel = new VesselRelayPersistence(vessel);
int totalCount = 0;
double totalDiameter = 0;
double totalAperture = 0;
double totalPowerCapacity = 0;
double minimumRelayWavelength = 1;
double maximumRelayWavelenght = 0;
foreach (var protoPart in vessel.protoVessel.protoPartSnapshots)
{
foreach (var protoModule in protoPart.modules)
{
if (protoModule.moduleName != "MicrowavePowerTransmitter" && protoModule.moduleName != "PhasedArrayTransmitter" && protoModule.moduleName != "BeamedPowerLaserTransmitter")
{
continue;
}
bool inRelayMode = bool.Parse(protoModule.moduleValues.GetValue("relay"));
bool isMergingBeams = false;
if (protoModule.moduleValues.HasValue("mergingBeams"))
{
isMergingBeams = bool.Parse(protoModule.moduleValues.GetValue("mergingBeams"));
}
// filter on transmitters
if (inRelayMode || isMergingBeams)
{
var wavelength = double.Parse(protoModule.moduleValues.GetValue("wavelength"));
var isMirror = bool.Parse(protoModule.moduleValues.GetValue("isMirror"));
var aperture = double.Parse(protoModule.moduleValues.GetValue("aperture"));
var powerCapacity = double.Parse(protoModule.moduleValues.GetValue("power_capacity"));
var diameter = protoModule.moduleValues.HasValue("diameter") ? double.Parse(protoModule.moduleValues.GetValue("diameter")) : aperture;
totalCount++;
totalAperture += aperture;
totalDiameter += diameter;
totalPowerCapacity += powerCapacity;
var relayWavelenghtMin = double.Parse(protoModule.moduleValues.GetValue("minimumRelayWavelenght"));
if (relayWavelenghtMin < minimumRelayWavelength)
{
minimumRelayWavelength = relayWavelenghtMin;
}
var relayWavelenghtMax = double.Parse(protoModule.moduleValues.GetValue("maximumRelayWavelenght"));
if (relayWavelenghtMax > maximumRelayWavelenght)
{
maximumRelayWavelenght = relayWavelenghtMax;
}
var relayData = relayVessel.SupportedTransmitWavelengths.FirstOrDefault(m => m.wavelength == wavelength);
if (relayData == null)
{
string partId = protoModule.moduleValues.GetValue("partId");
relayVessel.SupportedTransmitWavelengths.Add(new WaveLengthData()
{
partId = new Guid(partId),
count = 1,
apertureSum = aperture,
powerCapacity = powerCapacity,
wavelength = wavelength,
minWavelength = relayWavelenghtMin,
maxWavelength = relayWavelenghtMax,
isMirror = isMirror,
atmosphericAbsorption = double.Parse(protoModule.moduleValues.GetValue("atmosphericAbsorption"))
});
}
else
{
relayData.count++;
relayData.apertureSum += aperture;
relayData.powerCapacity += powerCapacity;
}
}
}
}
relayVessel.Aperture = (totalAperture / totalCount) * Approximate.Sqrt(totalCount);
relayVessel.Diameter = totalDiameter / totalCount;
relayVessel.PowerCapacity = totalPowerCapacity;
relayVessel.IsActive = totalCount > 0;
relayVessel.MinimumRelayWavelenght = minimumRelayWavelength;
relayVessel.MaximumRelayWavelenght = maximumRelayWavelenght;
return(relayVessel);
}
public static IVesselRelayPersistence getVesselRelayPersistenceForVessel(Vessel vessel)
{
// find all active tranmitters configured for relay
var relays = vessel.FindPartModulesImplementing <BeamedPowerTransmitter>().Where(m => m.IsRelay || m.mergingBeams).ToList();
if (relays.Count == 0)
{
return(null);
}
var relayPersistance = new VesselRelayPersistence(vessel);
relayPersistance.IsActive = true;
if (relayPersistance.IsActive)
{
return(relayPersistance);
}
foreach (var relay in relays)
{
var transmitData = relayPersistance.SupportedTransmitWavelengths.FirstOrDefault(m => m.wavelength == relay.wavelength);
if (transmitData == null)
{
// Add guid if missing
relay.partId = string.IsNullOrEmpty(relay.partId)
? Guid.NewGuid().ToString()
: relay.partId;
relayPersistance.SupportedTransmitWavelengths.Add(new WaveLengthData()
{
partId = new Guid(relay.partId),
count = 1,
apertureSum = relay.aperture,
powerCapacity = relay.power_capacity,
wavelength = relay.Wavelength,
minWavelength = relay.minimumRelayWavelenght,
maxWavelength = relay.maximumRelayWavelenght,
isMirror = relay.isMirror,
atmosphericAbsorption = relay.CombinedAtmosphericAbsorption
});
}
else
{
transmitData.count++;
transmitData.apertureSum += relay.aperture;
transmitData.powerCapacity += relay.power_capacity;
}
}
relayPersistance.Aperture = relays.Average(m => m.aperture) * Approximate.Sqrt(relays.Count);
relayPersistance.Diameter = relays.Average(m => m.diameter);
relayPersistance.PowerCapacity = relays.Sum(m => m.getPowerCapacity());
relayPersistance.MinimumRelayWavelenght = relays.Min(m => m.minimumRelayWavelenght);
relayPersistance.MaximumRelayWavelenght = relays.Max(m => m.maximumRelayWavelenght);
return(relayPersistance);
}
