blocks|key|1988091|text|将您的测量值表示为最低值的倍数。这样，你的列表就变成了1.00000，1.49919，2.49996。这些值的分数部分将非常接近1/N，因为N的某些值取决于你的最低值与基频的接近程度。我建议循环增加氮，直到你找到一个足够精细的匹配。在这种情况下，对于N=1+(也就是说，假设X=2.468是您的基本频率)，您会发现标准偏差为0.3333+(这三个值中有两个是X*1的.5+)，这是不可接受的高得令人无法接受的。对于N=2+(即假设2.468/2是您的基本频率)，您将发现几乎为零的标准差(所有三个值都在X/2倍数的.001内)，因此2.468/2是您的近似GCD。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1988092|我的计划的主要缺陷是，当最低的测量是最精确的时，效果最好，但情况可能并非如此。这可以通过多次执行整个操作来缓解，每次丢弃测量列表上的最低值，然后使用每次传递的结果列表来确定更精确的结果。另一种细化结果的方法是调整GCD，以最小化GCD的整数倍数与实测值之间的标准差。|1988093|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Express your measurements as multiples of the lowest one. Thus your list becomes 1.00000, 1.49919, 2.49996. The fractional parts of these values will be very close to 1/Nths, for some value of N dictated by how close your lowest value is to the fundamental frequency. I would suggest looping through increasing N until you find a sufficiently refined match. In this case, for N=1 (that is, assuming X=2.468 is your fundamental frequency) you would find a standard deviation of 0.3333 (two of the three values are .5 off of X * 1), which is unacceptably high. For N=2 (that is, assuming 2.468/2 is your fundamental frequency) you would find a standard deviation of virtually zero (all three values are within .001 of a multiple of X/2), thus 2.468/2 is your approximate GCD.

The major flaw in my plan is that it works best when the lowest measurement is the most accurate, which is likely not the case. This could be mitigated by performing the entire operation multiple times, discarding the lowest value on the list of measurements each time, then use the list of results of each pass to determine a more precise result. Another way to refine the results would be adjust the GCD to minimize the standard deviation between integer multiples of the GCD and the measured values.

blocks|key|760485|text|有趣的question...not轻松。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|760486|我想我应该看看样本值的比率：|760487|3.700+/+2.468+=1.499。|unordered-list-item|760488|6.1699+/+2.468+=2.4999。|760489|6.1699+/+3.700+=1.6675。|760490|然后我就会在这些结果中寻找一个简单的整数比率。|760491|1.499+~=+3/2|760492|2.4999+~=+5/2|760493|1.6675+~=+5/3|760494|我没有追踪它，但是沿着这条线的某个地方，你会发现一个1:1000的错误或者什么是足够好的，然后你回溯到找到基本近似的GCD。|760495|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|10|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|11|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|12|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|13|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|14|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|15|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|V|$]]

Interesting question...not easy.

I suppose I would look at the ratios of the sample values:

<ul>
<li>3.700 / 2.468 = 1.499...</li>
<li>6.1699 / 2.468 = 2.4999...</li>
<li>6.1699 / 3.700 = 1.6675...</li>
</ul>

And I'd then be looking for a simple ratio of integers in those results.

<ul>
<li>1.499 ~= 3/2</li>
<li>2.4999 ~= 5/2</li>
<li>1.6675 ~= 5/3</li>
</ul>

I haven't chased it through, but somewhere along the line, you decide that an error of 1:1000 or something is good enough, and you back-track to find the base approximate GCD.

blocks|key|1988185|text|我假设您的所有数字都是整数值的倍数。在我的其他解释中，A将表示您要查找的“根”频率，而B将表示您必须首先找到的数字数组。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1988186|您试图做的事情表面上类似于线性回归。您正在试图找到一个线性模型y=mx%2Bb，它将线性模型和一组数据之间的平均距离最小化。在您的例子中，b=0，m是根频率，y表示给定的值。最大的问题是没有显式地给出自变量X。关于X我们唯一知道的是，它的所有成员都必须是整数。|1988187|您的第一个任务是试图确定这些自变量。我目前能想到的最好的方法是假设给定的频率具有几乎连续的索引(x_1=x_0%2Bn)。所以B_0/B_1=(x_0)/(x_0%2Bn)给出了一个(希望的)小整数n，你可以利用这个事实，从x_0+=+n/(B_1-B_0)开始，从n=1开始，直到keep+(K)达到一定的阈值。在获得x_0+(初始索引)之后，您可以近似于根频率(A+=+B_0/x_0)。然后，您可以通过查找x_n+=+rnd(B_n/A)来近似其他索引。这种方法不太可靠，如果数据中的错误很大，很可能会失败。|CODE|1988188|如果你想更好地逼近根频率A，你可以使用线性回归来最小化线性模型的误差，现在你有了相应的因变量。最简单的方法是使用最小二乘拟合。沃尔夫拉姆的数学世界对这个问题有一个深入的数学处理，但是可以通过谷歌搜索找到一个相当简单的解释。|1988189|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Linear_regression|1|http://mathworld.wolfram.com/LeastSquaresFitting.html|2|http://www.physics.csbsju.edu/stats/least_squares.html^0|B|2|0|D|4|0|0|1C|9|1P|L|30|H|4Z|B|5M|G|0|1R|A|1|2V|7|2|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|H|3|I|5|6|7|15|8|@$9|16|A|17|B|J]|$9|18|A|19|B|J]|$9|1A|A|1B|B|J]|$9|1C|A|1D|B|J]|$9|1E|A|1F|B|J]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1G|8|@]|D|@$9|1H|A|1I|1|1J]|$9|1K|A|1L|1|1M]]|E|$]]|$1|M|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]|W|$5|P|Q|R|E|$S|X]]]]

I'm assuming all of your numbers are multiples of integer values. For the rest of my explanation, A will denote the "root" frequency you are trying to find and B will be an array of the numbers you have to start with.

What you are trying to do is superficially similar to <a href="http://en.wikipedia.org/wiki/Linear_regression" rel="noreferrer">linear regression</a>. You are trying to find a linear model y=mx+b that minimizes the average distance between a linear model and a set of data. In your case, b=0, m is the root frequency, and y represents the given values. The biggest problem is that the independent variables X are not explicitly given. The only thing we know about X is that all of its members must be integers.

Your first task is trying to determine these independent variables. The best method I can think of at the moment assumes that the given frequencies have nearly consecutive indexes (<code>x_1=x_0+n</code>). So <code>B_0/B_1=(x_0)/(x_0+n)</code> given a (hopefully) small integer n. You can then take advantage of the fact that <code>x_0 = n/(B_1-B_0)</code>, start with n=1, and keep ratcheting it up until k-rnd(k) is within a certain threshold. After you have x_0 (the initial index), you can approximate the root frequency (<code>A = B_0/x_0</code>). Then you can approximate the other indexes by finding <code>x_n = rnd(B_n/A)</code>. This method is not very robust and will probably fail if the error in the data is large.

If you want a better approximation of the root frequency A, you can use linear regression to minimize the error of the linear model now that you have the corresponding dependent variables. The easiest method to do so uses least squares fitting. <a href="http://mathworld.wolfram.com/LeastSquaresFitting.html" rel="noreferrer">Wolfram's Mathworld</a> has a in-depth mathematical treatment of the issue, but a <a href="http://www.physics.csbsju.edu/stats/least_squares.html" rel="noreferrer">fairly simple explanation</a> can be found with some googling.

blocks|key|761336|text|您可以运行欧几里得的gcd算法，只要小于0.01+(或您选择的少量)都是伪0。用你的数字：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|761337|3.700+=+1+*+2.468+%2B+1.232,
2.468+=+2+*+1.232+%2B+0.004.+|code-block|syntax|javascript|761338|所以前两个数字的伪gcd是1.232。现在，用最后一个数字来表示gcd：|761339|6.1699+=+5+*+1.232+%2B+0.0099.|761340|因此，1.232是伪gcd，乘数为2,3,5。要改进这一结果，可以对数据点进行线性回归：|761341|(2,2.468),+(3,3.7),+(5,6.1699).|761342|坡度为改进的伪gcd。|761343|注意:算法的第一部分是数值不稳定的--如果你从非常脏的数据开始，你就有麻烦了。|761344|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

You can run Euclid's gcd algorithm with anything smaller then 0.01 (or a small number of your choice) being a pseudo 0. With your numbers:

<pre><code>3.700 = 1 * 2.468 + 1.232,
2.468 = 2 * 1.232 + 0.004. 
</code></pre>

So the pseudo gcd of the first two numbers is 1.232. Now you take the gcd of this with your last number:

<pre><code>6.1699 = 5 * 1.232 + 0.0099.
</code></pre>

So 1.232 is the pseudo gcd, and the mutiples are 2,3,5. To improve this result, you may take the linear regression on the data points:

<pre><code>(2,2.468), (3,3.7), (5,6.1699).
</code></pre>

The slope is the improved pseudo gcd.

Caveat: the first part of this is algorithm is numerically unstable - if you start with very dirty data, you are in trouble.

blocks|key|760533|text|这让我想起了寻找实数的有理数近似的问题。标准技术是连续分式展开：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|760534|def+rationalizations(x):
++++assert+0+<=+x
++++ix+=+int(x)
++++yield+ix,+1
++++if+x+==+ix:+return
++++for+numer,+denom+in+rationalizations(1.0/(x-ix)):
++++++++yield+denom+%2B+ix+*+numer,+numer|code-block|syntax|javascript|760535|我们可以直接应用于乔纳森·莱弗勒和斯帕尔的方法：|760536|>>>+a,+b,+c+=+2.468,+3.700,+6.1699
>>>+b/a,+c/a
(1.4991896272285252,+2.4999594813614263)
>>>+list(itertools.islice(rationalizations(b/a),+3))
[(1,+1),+(3,+2),+(925,+617)]
>>>+list(itertools.islice(rationalizations(c/a),+3))
[(2,+1),+(5,+2),+(30847,+12339)]|760537|从每个序列中取出第一个足够好的近似值。(3/2和5/2在此)或者不是直接比较3.0/2.0和1.499189.，您可以注意到925/617使用的整数比3/2大得多，这使3/2成为一个很好的停止位置。|760538|你把哪一个数字除以并不重要。(例如，使用a/b和c/b可以得到2/3和5/3。)一旦有了整数比率，就可以使用shsmurfy的线性回归来细化基础的隐含估计。每个人都赢了！|760539|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This reminds me of the problem of finding good rational-number approximations of real numbers. The standard technique is a continued-fraction expansion:

<pre><code>def rationalizations(x):
 assert 0 &lt;= x
 ix = int(x)
 yield ix, 1
 if x == ix: return
 for numer, denom in rationalizations(1.0/(x-ix)):
 yield denom + ix * numer, numer
</code></pre>

We could apply this directly to Jonathan Leffler's and Sparr's approach:

<pre><code>&gt;&gt;&gt; a, b, c = 2.468, 3.700, 6.1699
&gt;&gt;&gt; b/a, c/a
(1.4991896272285252, 2.4999594813614263)
&gt;&gt;&gt; list(itertools.islice(rationalizations(b/a), 3))
[(1, 1), (3, 2), (925, 617)]
&gt;&gt;&gt; list(itertools.islice(rationalizations(c/a), 3))
[(2, 1), (5, 2), (30847, 12339)]
</code></pre>

picking off the first good-enough approximation from each sequence. (3/2 and 5/2 here.) Or instead of directly comparing 3.0/2.0 to 1.499189..., you could notice than 925/617 uses much larger integers than 3/2, making 3/2 an excellent place to stop.

It shouldn't much matter which of the numbers you divide by. (Using a/b and c/b you get 2/3 and 5/3, for instance.) Once you have integer ratios, you could refine the implied estimate of the fundamental using shsmurfy's linear regression. Everybody wins!

blocks|key|454495|text|我自己看到和使用的解是选择一个常数，比如说1000，用这个常量乘以所有数，把它们圈成整数，用标准算法求出这些整数的GCD，然后将结果除以所述常数(1000)。常数越大，精度越高。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|454496|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The solution which I've seen and used myself is to choose some constant, say 1000, multiply all numbers by this constant, round them to integers, find the GCD of these integers using the standard algorithm and then divide the result by the said constant (1000). The larger the constant, the higher the precision.

blocks|key|454502|text|当你先验地选择三个正公差(e1，e2，e3)时，这是shsmurfy's解的重新公式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|454503|然后，问题是搜索最小正整数(n1、n2、n3)，从而搜索最大根频率f，以便：|454504|f1+=+n1*f+%2B/-+e1
f2+=+n2*f+%2B/-+e2
f3+=+n3*f+%2B/-+e3|code-block|syntax|javascript|454505|我们假定0+<=+f1+<=+f2+<=+f3|454506|如果我们修复n1，那么我们得到以下关系：|454507|f++is+in+interval+I1=[(f1-e1)/n1+,+(f1%2Be1)/n1]
n2+is+in+interval+I2=[n1*(f2-e2)/(f1%2Be1)+,+n1*(f2%2Be2)/(f1-e1)]
n3+is+in+interval+I3=[n1*(f3-e3)/(f1%2Be1)+,+n1*(f3%2Be3)/(f1-e1)]|454508|我们从n1+=1开始，然后增量n1，直到间隔I2和I3包含一个整数，即与I3相同的floor(I2min)+different+from+floor(I2max)。|offset|length|style|CODE|454509|然后在区间n2中选择最小整数n3，在区间I3中选择最小整数n3。|454510|假定浮点误差的正态分布，根频率f的最可能估计是最小估计。|454511|J+=+(f1/n1+-+f)%5E2+%2B+(f2/n2+-+f)%5E2+%2B+(f3/n3+-+f)%5E2|454512|那是|454513|f+=+(f1/n1+%2B+f2/n2+%2B+f3/n3)/3|454514|如果间隔中有几个整数n2，n3，I2，I3，我们也可以选择最小剩余值的对。|454515|min(J)*3/2=(f1/n1)%5E2%2B(f2/n2)%5E2%2B(f3/n3)%5E2-(f1/n1)*(f2/n2)-(f1/n1)*(f3/n3)-(f2/n2)*(f3/n3)|454516|另一种变体是继续迭代，并尝试最小化另一个准则，如min(J+(n1+))*n1，直到f降到某一频率以下(n1达到一个上限)。|454517|entityMap^0|0|0|0|0|0|0|15|14|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1G|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|1H|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|1I|8|@$Q|1J|R|1K|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1L|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|F|7|1N|8|@]|9|@]|A|$G|H]]|$1|10|3|11|5|6|7|1O|8|@]|9|@]|A|$]]|$1|12|3|13|5|F|7|1P|8|@]|9|@]|A|$G|H]]|$1|14|3|15|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|16|3|17|5|F|7|1R|8|@]|9|@]|A|$G|H]]|$1|18|3|19|5|6|7|1S|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|1B|$]]

This is a reformulaiton of shsmurfy's solution when you a priori choose 3 positive tolerances (e1,e2,e3) 
The problem is then to search smallest positive integers (n1,n2,n3) and thus largest root frequency f such that:

<pre><code>f1 = n1*f +/- e1
f2 = n2*f +/- e2
f3 = n3*f +/- e3
</code></pre>

We assume 0 &lt;= f1 &lt;= f2 &lt;= f3 
If we fix n1, then we get these relations:

<pre><code>f is in interval I1=[(f1-e1)/n1 , (f1+e1)/n1]
n2 is in interval I2=[n1*(f2-e2)/(f1+e1) , n1*(f2+e2)/(f1-e1)]
n3 is in interval I3=[n1*(f3-e3)/(f1+e1) , n1*(f3+e3)/(f1-e1)]
</code></pre>

We start with n1 = 1, then increment n1 until the interval I2 and I3 contain an integer - that is <code>floor(I2min) different from floor(I2max)</code> same with I3 
We then choose smallest integer n2 in interval I2, and smallest integer n3 in interval I3.

Assuming normal distribution of floating point errors, the most probable estimate of root frequency f is the one minimizing

<pre><code>J = (f1/n1 - f)^2 + (f2/n2 - f)^2 + (f3/n3 - f)^2
</code></pre>

That is

<pre><code>f = (f1/n1 + f2/n2 + f3/n3)/3
</code></pre>

If there are several integers n2,n3 in intervals I2,I3 we could also choose the pair that minimize the residue

<pre><code>min(J)*3/2=(f1/n1)^2+(f2/n2)^2+(f3/n3)^2-(f1/n1)*(f2/n2)-(f1/n1)*(f3/n3)-(f2/n2)*(f3/n3)
</code></pre>

Another variant could be to continue iteration and try to minimize another criterium like min(J(n1))*n1, until f falls below a certain frequency (n1 reaches an upper limit)...

blocks|key|454586|text|我在MathStackExchange+(这里和这里)中找到了这个问题的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|454587|我只设法(到目前为止)测量基频的吸引力，给出了一个谐波频率的列表(遵循声音/音乐的名称)，如果您有较少的选项，并且可以计算每个选项的吸引力，然后选择最合适的选项，这是非常有用的。|454588|C&P+:我在MSE中的问题(这里的格式更漂亮)：|454589|V列表{v_1，v_2，.，v_n}，从低到高排序|unordered-list-item|454590|mean_sin(v，x)+=和(sin(2*pi*v_i/x)，i在{1，.，n}中)/n|454591|mean_cos(v，x)+=和(cos(2*pi*v_i/x)，i在{1，.，n}中)/n|454592|gcd_appeal(v，x)+=1-sqrt(mean_sin(v，x)%5E2+%2B+(mean_cos(v，x)+-+1)%5E2)/2，它在0,1区间产生一个数字。|style|BOLD|454593|目标是找到最大吸引力的x。下面是示例2.468、3.700、6.1699的(gcd_appeal)图，其中发现最佳GCD位于x+=+1.2337899957639993处。|454594|📷|atomic|454595|​|454596|divisibility编辑:您可能会发现这段代码很方便，用于计算除数的(模糊)(又名gcd_appeal)，它相对于红利列表；您可以使用它来测试候选人中哪一个是最佳除数。代码看起来很难看，因为我试图优化它以提高性能。|454597|++++//returns+the+mean+divisibility+of+dividend/divisor+as+a+value+in+the+range+[0+and+1]
++++//+0+means+no+divisibility+at+all
++++//+1+means+full+divisibility
++++public+double+divisibility(double+divisor,+double...+dividends)+{
++++++++double+n+=+dividends.length;
++++++++double+factor+=+2.0+/+divisor;
++++++++double+sum_x+=+-n;
++++++++double+sum_y+=+0.0;
++++++++double[]+coord+=+new+double[2];
++++++++for+(double+v+:+dividends)+{
++++++++++++coordinates(v+*+factor,+coord);
++++++++++++sum_x+%2B=+coord[0];
++++++++++++sum_y+%2B=+coord[1];
++++++++}
++++++++double+err+=+1.0+-+Math.sqrt(sum_x+*+sum_x+%2B+sum_y+*+sum_y)+/+(2.0+*+n);
++++++++//Might+happen+due+to+approximation+error
++++++++return+err+>=+0.0+?+err+:+0.0;
++++}

++++private+void+coordinates(double+x,+double[]+out)+{
++++++++//Bhaskara+performant+approximation+to
++++++++//out[0]+=+Math.cos(Math.PI*x);
++++++++//out[1]+=+Math.sin(Math.PI*x);
++++++++long+cos_int_part+=+(long)+(x+%2B+0.5);
++++++++long+sin_int_part+=+(long)+x;
++++++++double+rem+=+x+-+cos_int_part;
++++++++if+(cos_int_part+!=+sin_int_part)+{
++++++++++++double+common_s+=+4.0+*+rem;
++++++++++++double+cos_rem_s+=+common_s+*+rem+-+1.0;
++++++++++++double+sin_rem_s+=+cos_rem_s+%2B+common_s+%2B+1.0;
++++++++++++out[0]+=+(((cos_int_part+&+1L)+*+8L+-+4L)+*+cos_rem_s)+/+(cos_rem_s+%2B+5.0);
++++++++++++out[1]+=+(((sin_int_part+&+1L)+*+8L+-+4L)+*+sin_rem_s)+/+(sin_rem_s+%2B+5.0);
++++++++}+else+{
++++++++++++double+common_s+=+4.0+*+rem+-+4.0;
++++++++++++double+sin_rem_s+=+common_s+*+rem;
++++++++++++double+cos_rem_s+=+sin_rem_s+%2B+common_s+%2B+3.0;
++++++++++++double+common_2+=+((cos_int_part+&+1L)+*+8L+-+4L);
++++++++++++out[0]+=+(common_2+*+cos_rem_s)+/+(cos_rem_s+%2B+5.0);
++++++++++++out[1]+=+(common_2+*+sin_rem_s)+/+(sin_rem_s+%2B+5.0);
++++++++}
++++}|code-block|syntax|javascript|454598|entityMap|0|LINK|mutability|MUTABLE|url|https://math.stackexchange.com/questions/914288/how-to-find-the-approximate-basic-frequency-or-gcd-of-a-list-of-numbers|1|https://math.stackexchange.com/questions/1834472/approximate-greatest-common-divisor/2523521#2523521|2|IMAGE|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/79fb36b01ec97d8c41bc93b1ae0da3cd.png|imageAlt^0|L|2|0|O|2|1|0|0|0|0|0|0|0|A|0|0|A|1Q|M|0|0|1|2|0|0|0|C|N|2E|0|0^^$0|@$1|2|3|4|5|6|7|1M|8|@]|9|@$A|1N|B|1O|1|1P]|$A|1Q|B|1R|1|1S]]|C|$]]|$1|D|3|E|5|6|7|1T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1U|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1V|8|@]|9|@]|C|$]]|$1|K|3|L|5|J|7|1W|8|@]|9|@]|C|$]]|$1|M|3|N|5|J|7|1X|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|1Y|8|@$A|1Z|B|20|Q|R]]|9|@]|C|$]]|$1|S|3|T|5|6|7|21|8|@$A|22|B|23|Q|R]|$A|24|B|25|Q|R]]|9|@]|C|$]]|$1|U|3|V|5|W|7|26|8|@]|9|@$A|27|B|28|1|29]]|C|$]]|$1|X|3|Y|5|6|7|2A|8|@]|9|@]|C|$]]|$1|Z|3|10|5|6|7|2B|8|@$A|2C|B|2D|Q|R]|$A|2E|B|2F|Q|R]]|9|@]|C|$]]|$1|11|3|12|5|13|7|2G|8|@]|9|@]|C|$14|15]]|$1|16|3|-4|5|6|7|2H|8|@]|9|@]|C|$]]]|17|$18|$5|19|1A|1B|C|$1C|1D]]|1E|$5|19|1A|1B|C|$1C|1F]]|1G|$5|1H|1A|1I|C|$1J|1K|1L|-4]]]]

I found this question looking for answers for mine in MathStackExchange (<a href="https://math.stackexchange.com/questions/914288/how-to-find-the-approximate-basic-frequency-or-gcd-of-a-list-of-numbers">here</a> and <a href="https://math.stackexchange.com/questions/1834472/approximate-greatest-common-divisor/2523521#2523521">here</a>).

I've only managed (yet) to measure the appeal of a fundamental frequency given a list of harmonic frequencies (following the sound/music nomenclature), which can be useful if you have a reduced number of options and is feasible to compute the appeal of each one and then choose the best fit.

C&amp;P from my question in MSE (there the formatting is prettier):

<ul>
<li>being v the list {v_1, v_2, ..., v_n}, ordered from lower to higher</li>
<li>mean_sin(v, x) = sum(sin(2*pi*v_i/x), for i in {1, ...,n})/n</li>
<li>mean_cos(v, x) = sum(cos(2*pi*v_i/x), for i in {1, ...,n})/n</li>
<li>gcd_appeal(v, x) = 1 - sqrt(mean_sin(v, x)^2 + (mean_cos(v, x) - 1)^2)/2, which yields a number in the interval [0,1].</li>
</ul>

The goal is to find the x that maximizes the appeal. Here is the (gcd_appeal) graph for your example [2.468, 3.700, 6.1699], where you find that the optimum GCD is at x = 1.2337899957639993
<a href="https://i.stack.imgur.com/Sa7Ut.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/Sa7Ut.png" alt="enter image description here"></a>

Edit:
You may find handy this JAVA code to calculate the (fuzzy) divisibility (aka gcd_appeal) of a divisor relative to a list of dividends; you can use it to test which of your candidates makes the best divisor. The code looks ugly because I tried to optimize it for performance.

<pre class="lang-java prettyprint-override"><code> //returns the mean divisibility of dividend/divisor as a value in the range [0 and 1]
 // 0 means no divisibility at all
 // 1 means full divisibility
 public double divisibility(double divisor, double... dividends) {
 double n = dividends.length;
 double factor = 2.0 / divisor;
 double sum_x = -n;
 double sum_y = 0.0;
 double[] coord = new double[2];
 for (double v : dividends) {
 coordinates(v * factor, coord);
 sum_x += coord[0];
 sum_y += coord[1];
 }
 double err = 1.0 - Math.sqrt(sum_x * sum_x + sum_y * sum_y) / (2.0 * n);
 //Might happen due to approximation error
 return err &gt;= 0.0 ? err : 0.0;
 }

 private void coordinates(double x, double[] out) {
 //Bhaskara performant approximation to
 //out[0] = Math.cos(Math.PI*x);
 //out[1] = Math.sin(Math.PI*x);
 long cos_int_part = (long) (x + 0.5);
 long sin_int_part = (long) x;
 double rem = x - cos_int_part;
 if (cos_int_part != sin_int_part) {
 double common_s = 4.0 * rem;
 double cos_rem_s = common_s * rem - 1.0;
 double sin_rem_s = cos_rem_s + common_s + 1.0;
 out[0] = (((cos_int_part &amp; 1L) * 8L - 4L) * cos_rem_s) / (cos_rem_s + 5.0);
 out[1] = (((sin_int_part &amp; 1L) * 8L - 4L) * sin_rem_s) / (sin_rem_s + 5.0);
 } else {
 double common_s = 4.0 * rem - 4.0;
 double sin_rem_s = common_s * rem;
 double cos_rem_s = sin_rem_s + common_s + 3.0;
 double common_2 = ((cos_int_part &amp; 1L) * 8L - 4L);
 out[0] = (common_2 * cos_rem_s) / (cos_rem_s + 5.0);
 out[1] = (common_2 * sin_rem_s) / (sin_rem_s + 5.0);
 }
 }
</code></pre>

Suppose you have a list of floating point numbers that are approximately multiples of a common quantity, for example 

2.468, 3.700, 6.1699

which are approximately all multiples of 1.234. How would you characterize this "approximate gcd", and how would you proceed to compute or estimate it?

Strictly related to my answer to <a href="https://stackoverflow.com/questions/435533/detecting-the-fundamental-frequency">this question</a>.

"Approximate" greatest common divisor

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

假设您有一个浮点数列表，它大约是一个公共数量的的倍数，例如2.468，3.700，6.1699大约都是1.234的倍数。你将如何描述这个“近似的gcd"，你将如何计算或估计它？与我对的回答有严格的关系。

问“近似”最大公因子
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“近似”最大公因子EN