Well i just got a problem, with the simple following code:
trace( 0.01+0.05 ); // 0.060000000000000005
trace( 0.03-0.01 ); // 0.019999999999999997
I mean i just want 0.01+0.05 give me 0.06 and 0.03-0.01 give me 0.02.
Does someone have an idea how to retrieve the correct results ?
The imprecision is due to floating point arithmetic. 0.01, 0.05 and 0.03 are all floating point literals. Not every number (in fact, very few numbers) can be represented precisely in floating point.
For example, 0.5 can be but, 0.06 cannot. As a rule of thumb the first 15 significant figures will be correct.
For more details, see http://en.wikipedia.org/wiki/Floating_point
trace(Math.format((0.01+0.05), 2));
Related
in octave-online.net the vpa() function returns me the non precise result. If i try some computation with a lot digits behind decimal after 49's digit is the result zero. Is there some trick how to compute with a lot digits behind decimal?
vpa((pi-1),100)
returns:
2.141592653589793115997963468544185161590576171875000000000000000000000000000000000000000000000000000
I have similar problem for similar inputs with different length(e.g. vpa((113/111),100))
Thank You.
trying:
vpa((pi-1),100)
expecting:
2.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068
With vpa((p-1),100) the calculation of pi-1 is done using limited precision and the (imprecise) result is then applied to the vpa function.
Instead, the vpa function needs to make the calculation:
vpa('pi-1',100)
giving the expected result:
2.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068
See more details on the vpa reference page.
I want to compare two smoothing methods for a bigram model:
Add-one smoothing
Interpolated Absolute Discounting
For the first method, I found some codes.
def calculate_bigram_probabilty(self, previous_word, word):
bigram_word_probability_numerator = self.bigram_frequencies.get((previous_word, word), 0)
bigram_word_probability_denominator = self.unigram_frequencies.get(previous_word, 0)
if self.smoothing:
bigram_word_probability_numerator += 1
bigram_word_probability_denominator += self.unique__bigram_words
return 0.0 if bigram_word_probability_numerator == 0 or bigram_word_probability_denominator == 0 else float(
bigram_word_probability_numerator) / float(bigram_word_probability_denominator)
However, I found nothing for the second method except for some references for 'KneserNeyProbDist'. However, this is for trigrams!
How can I change my code above to calculate it? The parameters of this method must be estimated from a development-set.
In this answer I just clear up a few things that I just found about your problem, but I can't provide a coded solution.
with KneserNeyProbDist you seem to refer to a python implementation of that problem: https://kite.com/python/docs/nltk.probability.KneserNeyProbDist
There exists an article about Kneser–Ney smoothing on wikipedia: https://en.wikipedia.org/wiki/Kneser%E2%80%93Ney_smoothing
The article above links this tutorial: https://nlp.stanford.edu/~wcmac/papers/20050421-smoothing-tutorial.pdf but this has a small fault on the most important page 29, the clear text is this:
Modified Kneser-Ney
Chen and Goodman introduced modified Kneser-Ney:
Interpolation is used instead of backoff. Uses a separate discount for one- and two-counts instead of a single discount for all counts. Estimates discounts on held-out data instead of using a formula
based on training counts.
Experiments show all three modifications improve performance.
Modified Kneser-Ney consistently had best performance.
Regrettable the modified Version is not explained in that document.
The original documentation by Chen & Goodman luckily is available, the Modified Kneser–Ney smoothing is explained on page 370 of this document: http://u.cs.biu.ac.il/~yogo/courses/mt2013/papers/chen-goodman-99.pdf.
I copy the most important text and formula here as screenshot:
So the Modified Kneser–Ney smoothing now is known and seems being the best solution, just translating the description beside formula in running code is still one step to do.
It might be helpful that below the shown text (above in screenshot) in the original linked document is still some explanation that might help to understand the raw description.
I have some question about fixed version kiss_fft's butterfly computation.
in "kf_bfly2", input divide by 2 use "C_FIXDIV",
in "kf_bfly3", input divide by 3 use "C_FIXDIV",
in "kf_bfly4", input divide by 4 use "C_FIXDIV",
in "kf_bfly5", input divide by 5 use "C_FIXDIV",
in "kiss_fftr" also use "C_FIXDIV",from the point of view of FFT algorithm,it's no use, It seems using "C_FIXDIV" just to prevent overflow.
but if the input is Q15, what's the output Q value?
the output Q value is consistent with input's?
whether the output magnitude is smaller than the expected?
I'm really puzzled.
I am currently trying to simulate ballistics on an object, that is otherwise not affected by physics. To be precise, I have a rocket-like projectile, that is following an parabolic arc from origin to target with a Lerp. To make it more realistic, I want it not to move at constant speed, but to slow down towards the climax and speed up on its way back down.
I have used the Mathf.Smoothstep function to do the exact opposite of what i need on other objects, i.e. easing in and out of the motion.
So my question is: How do I get an inverted Smoothstep?
I found out that what i would need is actually the inverted formula to smoothstep [ x * x*(3 - 2*x) ], but being not exactly a math genius, I have no idea how to do that. All I got from online calculators was some pretty massive new function, which I'm afraid would not be very efficient.
So maybe there is a function that comes close to an inverted smoothstep, but isn't as complex to compute.
Any help on this would be much appreciated
Thanks in advance,
Tux
Correct formula is available here:
https://www.shadertoy.com/view/MsSBRh
Solution by Inigo Quilez and TinyTexel
Flt SmoothCubeInv(Flt y)
{
if(y<=0)return 0;
if(y>=1)return 1;
return 0.5f-Sin(asinf(1-2*y)/3);
}
I had a similar problem. For me, mirroring the curve in y = x worked:
So an implementation example would be:
float Smooth(float x) {
return x + (x - (x * x * (3.0f - 2.0f * x)));
}
This function has no clamping, so that may have to be added if x can go outside the 0 to 1 interval.
Wolfram Alpha example
If you're moving transforms, it is often a good idea to user iTween or similar animation libraries instead of controlling animation yourself. They have a an easy API and you can set up easing mode too.
But if you need this as a math function, you can use something like this:
y = 0.5 + (x > 0.5 ? 1 : -1) * Mathf.Pow(Mathf.Abs(2x - 1),p)/2
Where p is the measure of steepness that you want. Here's how it looks:
You seem to want a regular parabola. See the graph of this function:
http://www.wolframalpha.com/input/?i=-%28x%2A2-1%29%5E2%2B1
Which is the graph that seems to do what you want: -(x*2-1)^2+1
It goes from y=0 to y=1 and then back again between x=0 and x=1, staying a bit at the top around x=0.5 . It's what you want, if I understood it correctly.
Other ways to write this function, according to wolfram alpha, would be -(4*(x-1)*x) and (4-4*x)*x
Hope it helps.
I am trying to query all from a table of points, all of the points that are inside a certain polygon. I have tried to use st_contains() and for some reason it just won't work.
To made it simple, I have made a table with the points (1,1),(0,0),(100,100) I have used:
GeomFromText('Point(0 0)')
This is my query:
SELECT id, astext(point) FROM points WHERE st_within(point,GeomFromText('Polygon(10 10, 10 -10, -10 -10, -10 10, 10 10)'))
I have also found this question, which made me feel confident that there is something very big that I'm missing...
Please, tell me what I'm doing wrong...
Thanks :)
There are two methods to determine if a point is within a polygon (winding number or the even odd rule).
https://www.youtube.com/watch?v=AHs2Ugxo7-8
http://en.wikipedia.org/wiki/Even%E2%80%93odd_rule
This depends how you wish to treat a polygon.
Apparently, it is very important that the "Polygon Creation String" will use at least 2 sets of parentheses, even if it's a 1-line polygon. for example:
GOOD Polygon Creation:
GeomFromText('Polygon((10 10,10 -10,-10 -10,10 10))')
BAD Polygon Creation:
GeomFromText('Polygon(10 10,10 -10,-10 -10,10 10)')