// Overrides the ConvertFrom method of TypeConverter.
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value is string)
{
uint32 result = uint.Parse((string)value);
return(result);
}
return(base.ConvertFrom(context, culture, value));
}
protected void RecalcualteTrustValue()
{
const float PUBLISHPOINTSSPERSUBNET = 10.0f;
// The trustvalue is supposed to be an indicator how trustworthy/important (or spamy) this entry is and lies between 0 and ~10000,
// but mostly we say everything below 1 is bad, everything above 1 is good. It is calculated by looking at how many differnt
// IPs/24 have published this entry and how many entries each of those IPs have.
// Each IP/24 has x (say 3) points. This means if one IP publishs 3 differnt entries without any other IP publishing those entries,
// each of those entries will have 3 / 3 = 1 Trustvalue. Thats fine. If it publishes 6 alone, each entry has 3 / 6 = 0.5 trustvalue - not so good
// However if there is another publisher for entry 5, which only publishes this entry then we have 3/6 + 3/1 = 3.5 trustvalue for this entry
//
// Whats the point? With this rating we try to avoid getting spammed with entries for a given keyword by a small IP range, which blends out
// all other entries for this keyword do to its amount as well as giving an indicator for the searcher. So if we are the node to index "Knoppix", and someone
// from 1 IP publishes 500 times "knoppix casino 500% bonus.txt", all those entries will have a trsutvalue of 0.006 and we make sure that
// on search requests for knoppix, those entries are only returned after all entries with a trustvalue > 1 were sent (if there is still space).
//
// Its important to note that entry with < 1 do NOT get ignored or singled out, this only comes into play if we have 300 more results for
// a search request rating > 1
if (m_pliPublishingIPs == NULL)
{
ASSERT(false);
return;
}
dwLastTrustValueCalc = ::GetTickCount();
m_fTrustValue = 0;
ASSERT(!m_pliPublishingIPs->IsEmpty());
for (POSITION pos = m_pliPublishingIPs->GetHeadPosition(); pos != NULL; m_pliPublishingIPs->GetNext(pos))
{
structPublishingIP curEntry = m_pliPublishingIPs->GetAt(pos);
uint32 nCount = 0;
s_mapGlobalPublishIPs.Lookup(curEntry.m_uIP & 0xFFFFFF00 /* /24 netmask, take care of endian if needed*/, nCount);
if (nCount > 0)
{
m_fTrustValue += PUBLISHPOINTSSPERSUBNET / nCount;
}
else
{
DebugLogError(_T("Kad: EntryTrack: Inconsistency RecalcualteTrustValue()"));
ASSERT(false);
}
}
}
/// <summary>
/// Updates the Properties used in CommonData.
/// </summary>
/// <param name="data">The ETAPU11 data.</param>
public void Refresh(SYMO823MData data)
{
if (data != null)
{
// Multiple MPPT Inverter Extension Model (I160)
I160ID = data.I160ID;
I160Length = data.I160Length;
ScaleFactorCurrent = data.ScaleFactorCurrent;
ScaleFactorVoltage = data.ScaleFactorVoltage;
ScaleFactorPower = data.ScaleFactorPower;
ScaleFactorEnergy = data.ScaleFactorEnergy;
GlobalEvents = data.GlobalEvents;
NumberOfModules = data.NumberOfModules;
TimestampPeriod = data.TimestampPeriod;
InputID1 = data.InputID1;
InputIDString1 = data.InputIDString1;
CurrentDC1 = data.CurrentDC1;
VoltageDC1 = data.VoltageDC1;
PowerDC1 = data.PowerDC1;
LifetimeEnergy1 = data.LifetimeEnergy1;
Timestamp1 = data.Timestamp1;
Temperature1 = data.Temperature1;
OperatingState1 = data.OperatingState1;
ModuleEvents1 = data.ModuleEvents1;
InputID2 = data.InputID2;
InputIDString2 = data.InputIDString2;
CurrentDC2 = data.CurrentDC2;
VoltageDC2 = data.VoltageDC2;
PowerDC2 = data.PowerDC2;
LifetimeEnergy2 = data.LifetimeEnergy2;
Timestamp2 = data.Timestamp2;
Temperature2 = data.Temperature2;
OperatingState2 = data.OperatingState2;
ModuleEvents2 = data.ModuleEvents2;
}
Status = data?.Status ?? Uncertain;
}
static void Do()
{
var c = 4;
var inArr = new int32 [c];
for (int _i = 0; _i < c; _i++) { inArr[_i] = 2; }
inArr[c-2] = 1;
int32 size = inArr.Length;
var rules = new Rule[] {new Rule(1,2,3,0,0),new Rule(2,3,2,0,0),new Rule(2,1,0,0,0),new Rule(3,2,0,0,0)};
var nTermRules = (from rule in rules where rule.c > 0 select rule).ToArray();
int32 nTerms = 3;
string platformName = "*";
Cl.DeviceType deviceType = Cl.DeviceType.Default;
ComputeProvider provider;
try
{
provider = ComputeProvider.Create(platformName, deviceType);
}
catch (PlatformNotSupportedException ex)
{
Console.WriteLine(ex.Message);
return;
}
var commandQueue = new CommandQueue(provider, provider.Devices.First());
var bArr = new int32[size * size * nTerms * cellDataRepresentationLength];
var rulesArr = new uint32[nTermRules.Length * ruleRepresentationLength];
for (int i = 0; i < size; i++)
{
for (int j = 0; j < rules.Length; j++)
{
if (inArr[i] == (rules[j]).b && (rules[j]).c == 0)
{
var _base = (i * nTerms + (int)(rules[j].a - 1)) * cellDataRepresentationLength;
bArr[_base] = rules[j].a;
//bArr[_base + 1] = 0;
//bArr[_base + 2] = (rules[j].lblNum == 0 ? 1 : 0);
///bArr[_base + 3] = rules[j].lblNum;
//bArr[_base + 4] = rules[j].lblWeight;
}
}
}
for (int i = 0; i < nTermRules.Length; i++)
{
var _base = i * ruleRepresentationLength;
rulesArr[_base] = (uint32)(uint)(nTermRules[i].a << 16 | nTermRules[i].b);
rulesArr[_base + 1] = (uint32)(uint)nTermRules[i].c;
//rulesArr[_base + 3] = rules[i].lblNum;
//rulesArr[_base + 4] = rules[i].lblWeight;
}
var buffer = new Buffer<int32>(provider, Operations.ReadWrite, Memory.Device, bArr);
var rulesBuffer = new Buffer<uint32>(provider, Operations.ReadOnly, Memory.Device, rulesArr);
int32 rLength = nTermRules.Length;
var processRow = provider.Compile<_1D, int32, Buffer<int32>, Buffer<uint32>>(
(range, l, a, _rules) =>
from r in range
let i = r.GlobalID0
let nT = nTerms
let _base = nT * size
let res_id_base = (l * _base) + i * nT
let iter = provider.Loop(0, l, kIdx=>
from k in kIdx
let left_base_idx = (k * _base) + i * nTerms
let right_base_idx = ((l - k - 1) * _base) + (k + i + 1) * nTerms
let iter2 = provider.Loop(0, rLength, rIdxs =>
from rId in rIdxs
let rule_base = rId * ruleRepresentationLength
let rule_a_b = _rules[rule_base]
let rule_a = (int)((rule_a_b >> 16) & 0xFFFF)
let rule_b = (int)(rule_a_b & 0xFFFF)
let rule_c = (int)(_rules[rule_base + 1] | 0)
let res_id = res_id_base + ((int)(uint)rule_a - 1)
select new[]{(rule_c != 0
& rule_c == a[right_base_idx + (rule_c - 1)]
& rule_b == a[left_base_idx + (rule_b - 1)])
? a[res_id] <= rule_a
: ((Brahma.Set<int32>)null)})
select (Brahma.Set<int32>[])null)
select (Brahma.Set<int32>[])null);
for (int l = 1; l < size; l++)
{
commandQueue.Add(processRow.Run(new _1D(size - l), l, buffer, rulesBuffer)).Finish();
}
commandQueue.Add(buffer.Read(0, size * size * nTerms * cellDataRepresentationLength, bArr)).Finish();
toMatrix(bArr, (int)(size * nTerms * cellDataRepresentationLength));
buffer.Dispose();
commandQueue.Dispose();
provider.Dispose();
}
static void Do()
{
var c = 4;
var inArr = new int32 [c];
for (int _i = 0; _i < c; _i++)
{
inArr[_i] = 2;
}
inArr[c - 2] = 1;
int32 size = inArr.Length;
var rules = new Rule[] { new Rule(1, 2, 3, 0, 0), new Rule(2, 3, 2, 0, 0), new Rule(2, 1, 0, 0, 0), new Rule(3, 2, 0, 0, 0) };
var nTermRules = (from rule in rules where rule.c > 0 select rule).ToArray();
int32 nTerms = 3;
string platformName = "*";
Cl.DeviceType deviceType = Cl.DeviceType.Default;
ComputeProvider provider;
try
{
provider = ComputeProvider.Create(platformName, deviceType);
}
catch (PlatformNotSupportedException ex)
{
Console.WriteLine(ex.Message);
return;
}
var commandQueue = new CommandQueue(provider, provider.Devices.First());
var bArr = new int32[size * size * nTerms * cellDataRepresentationLength];
var rulesArr = new uint32[nTermRules.Length * ruleRepresentationLength];
for (int i = 0; i < size; i++)
{
for (int j = 0; j < rules.Length; j++)
{
if (inArr[i] == (rules[j]).b && (rules[j]).c == 0)
{
var _base = (i * nTerms + (int)(rules[j].a - 1)) * cellDataRepresentationLength;
bArr[_base] = rules[j].a;
//bArr[_base + 1] = 0;
//bArr[_base + 2] = (rules[j].lblNum == 0 ? 1 : 0);
///bArr[_base + 3] = rules[j].lblNum;
//bArr[_base + 4] = rules[j].lblWeight;
}
}
}
for (int i = 0; i < nTermRules.Length; i++)
{
var _base = i * ruleRepresentationLength;
rulesArr[_base] = (uint32)(uint)(nTermRules[i].a << 16 | nTermRules[i].b);
rulesArr[_base + 1] = (uint32)(uint)nTermRules[i].c;
//rulesArr[_base + 3] = rules[i].lblNum;
//rulesArr[_base + 4] = rules[i].lblWeight;
}
var buffer = new Buffer <int32>(provider, Operations.ReadWrite, Memory.Device, bArr);
var rulesBuffer = new Buffer <uint32>(provider, Operations.ReadOnly, Memory.Device, rulesArr);
int32 rLength = nTermRules.Length;
var processRow = provider.Compile <_1D, int32, Buffer <int32>, Buffer <uint32> >(
(range, l, a, _rules) =>
from r in range
let i = r.GlobalID0
let nT = nTerms
let _base = nT * size
let res_id_base = (l * _base) + i * nT
let iter = provider.Loop(0, l, kIdx =>
from k in kIdx
let left_base_idx = (k * _base) + i * nTerms
let right_base_idx = ((l - k - 1) * _base) + (k + i + 1) * nTerms
let iter2 = provider.Loop(0, rLength, rIdxs =>
from rId in rIdxs
let rule_base = rId * ruleRepresentationLength
let rule_a_b = _rules[rule_base]
let rule_a = (int)((rule_a_b >> 16) & 0xFFFF)
let rule_b = (int)(rule_a_b & 0xFFFF)
let rule_c = (int)(_rules[rule_base + 1] | 0)
let res_id = res_id_base + ((int)(uint)rule_a - 1)
select new[] { (rule_c != 0
& rule_c == a[right_base_idx + (rule_c - 1)]
& rule_b == a[left_base_idx + (rule_b - 1)])
? a[res_id] <= rule_a
: ((Brahma.Set <int32>)null) })
select(Brahma.Set <int32>[]) null)
select(Brahma.Set <int32>[]) null);
for (int l = 1; l < size; l++)
{
commandQueue.Add(processRow.Run(new _1D(size - l), l, buffer, rulesBuffer)).Finish();
}
commandQueue.Add(buffer.Read(0, size * size * nTerms * cellDataRepresentationLength, bArr)).Finish();
toMatrix(bArr, (int)(size * nTerms * cellDataRepresentationLength));
buffer.Dispose();
commandQueue.Dispose();
provider.Dispose();
}
