标签: division

编写代码以确定数字是否可被3整除.函数的输入是单个位,0或1,如果到目前为止接收的数字是可被3整除的数字的二进制表示,则输出应为1,否则零.

例子:

input  "0":       (0)  output 1
inputs "1,0,0":   (4)  output 0
inputs "1,1,0,0": (6)  output 1

这是基于面试问题.我要求绘制逻辑门,但由于这是stackoverflow,我会接受任何编码语言.硬件实现的奖励点(verilog等).

部分a(简单):第一个输入是MSB.

b部分(稍微难一点):第一个输入是LSB.

c部分(困难):哪一个更快更小,(a)或(b)？(理论上不是Big-O意义上的,但实际上更快/更小.)现在采用较慢/较大的一个,并使其快/小与更快/更小的一个.

我有一个大的浮点数数据集.我遍历它们并评估它们np.log(x)中的每一个.我明白了

RuntimeWarning: divide by zero encountered in log

如果发生此错误,我想解决此问题并返回0.

我正在考虑定义一个新函数:

def safe_ln(x):
    #returns: ln(x) but replaces -inf with 0
    l = np.log(x)
    #if l = -inf:
    l = 0
    return l

基本上,我需要一种测试输出的方法,-inf但我不知道如何继续.谢谢您的帮助!

我得到了这个C代码.

#include <stdio.h>

int main(void)
{
        int n, d, i;
        double t=0, k;
        scanf("%d %d", &n, &d);
        t = (1/100) * d;
        k = n / 3;
        printf("%.2lf\t%.2lf\n", t, k);
        return 0;
}

我想知道为什么我的变量't'总是为零(在printf函数中)？

1/2

给

0

正如它应该.然而,

-1/2

给

-1

,但我希望它向0舍入(即我希望-1/2为0),无论它是正还是负.最好的方法是什么？

我目前正在研究如何使用各种现代处理器的快速单精度浮点倒数功能来计算基于定点Newton-Raphson迭代的64位无符号整数除法的起始近似.它需要尽可能精确地计算2 ⁶⁴ /除数,其中初始近似必须小于或等于数学结果,基于以下定点迭代的要求.这意味着这种计算需要低估.我目前有以下代码,基于广泛的测试,效果很好:

#include <stdint.h> // import uint64_t
#include <math.h> // import nextafterf()

uint64_t divisor, recip;
float r, s, t;

t = uint64_to_float_ru (divisor); // ensure t >= divisor
r = 1.0f / t;
s = 0x1.0p64f * nextafterf (r, 0.0f);
recip = (uint64_t)s; // underestimate of 2**64 / divisor 

虽然这段代码很实用,但在大多数平台上并不是很快.一个显而易见的改进,需要一些特定于机器的代码,是r = 1.0f / t用代码来替换除法,该代码利用硬件提供的快速浮点倒数.这可以通过迭代来增强,以产生在数学结果的1 ulp内的结果,因此在现有代码的上下文中产生低估.x86_64的示例实现将是:

#include <xmmintrin.h>
/* Compute 1.0f/a almost correctly rounded. Halley iteration with cubic convergence */
inline float fast_recip_f32 (float a)
{
    __m128 t; …

我需要为我正在构建的程序编写一个会计例程,它将给出一个十进制的偶数除以整数.例如:

$143.13 / 5 =

28.62
28.62
28.63
28.63
28.63

我在这里看过这篇文章:在c#中均匀划分,但似乎它只适用于整数除法.想知道这个问题的优雅解决方案吗？

我正在研究GPU设备,它具有非常高的除法整数延迟,数百个周期.我希望优化分歧.

分母中的所有除法都在集合{1,3,6,10}中,但分子是运行时正值,大约为32000或更小.由于内存限制,查找表可能不是一个好的选择.

你能想到其他选择吗？我曾想过计算浮点反转,并使用它们来乘以分子.

谢谢

PS.谢谢你们.位移黑客真的很酷.为了从舍入中恢复,我使用以下C段:

// q = m/n
q += (n*(j +1)-1) < m;

我正在Java应用程序中尝试这个简单的计算:

System.out.println("b=" + (1 - 7 / 10));

显然我想要b=0.3输出,但这就是我得到的b=1.

什么？!为什么会这样？

如果我做:

System.out.println("b=" + (1 - 0.7));

我得到了正确的结果b=0.3.

这里出了什么问题？

我正在尝试将一个timedelta对象与另一个对象分开以计算服务器正常运行时间:

>>> import datetime
>>> installation_date=datetime.datetime(2010,8,01)
>>> down_time=datetime.timedelta(seconds=1400)
>>> server_life_period=datetime.datetime.now()-installation_date
>>> down_time_percentage=down_time/server_life_period
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for /: 'datetime.timedelta' 
           and 'datetime.timedelta'

我知道这已经在Python 3.2中得到了解决,但除了计算微秒,秒和天数以及除以？之外,还有一种方便的方法可以在Python的早期版本中处理它吗？

谢谢,

亚当

我需要在代码的热路径中执行一些整数除法.我已经通过分析和循环计数确定了整数除法对我造成的损失.我希望我能做些什么来强化将分裂降低到更便宜的东西.

在这条路径中,我除以2 ^ n + 1,其中n是可变的.基本上我想优化此函数以删除除法运算符:

unsigned long compute(unsigned long a, unsigned int n)
{
    return a / ((1 << n) + 1);
}

如果我除以2 ^ n,我只需用右移n替换div.如果我用常数除法,我会让编译器强度减少那个特定的除法,可能会把它变成乘法和一些变化.

是否存在适用于2 ^ n + 1的类似优化？

编辑:这里可以是任意64位整数.n只取10和25之间的几个值.我当然可以为每个n预先计算一些值,但不能为a计算.