HR as far as I understand it 20% of the blocks are ASIC, 20% are Scrypt, 60% are GPU (I do not know if these are equally distributed).
That's not the issue. The block find distribution is 20/20/20/20/20. About that there is no doubt.
The question is how does MultiShield adjust each algo's diff and as a function of exactly what? We know that before the most recent hardfork, global network hashrate (that is the combined total of the 5 algos) was key, and that all the algos diffs adjusted in response to changes in aggregate hashrate. The question is how much did that change? To what precise degree are the algos currently independent, and to what degree are they still inter-dependent?
I suggest reading the source code. ...with basic coding skills and the source code mentioned (that is freely available to the public), anyone can confirm it.
Forgive me mental, your post was just brought to my attention.
Read the code to find your answer? Are you off your rocker?
Could anyone imagine someone from Ubuntu saying something like that? From Redhat? SUSE? Any of the principal distros?
Could anyone imagine that such important, critical and key information isn't even documented in the first place?And then, when someone asks, the answers are
first to ignore,
second to be flippant,
third to seriously suggest it's not important,
fourth to disqualify and personally attack the person asking . . .
Does that sound normal to everyone?
We, the end users should read the code to answers central questions about how DigiByte works? Are you serious? (And don't play coy by saying I didn't quote your entire post - the rest was superfluous, and certainly didn't answer the questions.)
Again, is there anyone on the DigiByte team professional enough to start that basic documentation that everyone can understand by putting the following code in layman's terms instead of suggesting we all need to learn to code? (I make that a general question to all, not just to you, since Jared did the same thing, albeit more indirectly and with much more obfuscation.
//Global retarget
CBigNum bnNew;
bnNew.SetCompact(pindexPrevAlgo->nBits);
bnNew *= nActualTimespan;
bnNew /= nAveragingTargetTimespanV4;
//Per-algo retarget
int nAdjustments = pindexPrevAlgo->nHeight + NUM_ALGOS - 1 - pindexLast->nHeight;
if (nAdjustments > 0)
{
for (int i = 0; i < nAdjustments; i++)
{
bnNew *= 100;
bnNew /= (100 + nLocalTargetAdjustment);
}
}
else if (nAdjustments < 0)//make it easier
{
for (int i = 0; i < -nAdjustments; i++)
{
bnNew *= (100 + nLocalTargetAdjustment);
bnNew /= 100;
}
}