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); }