小编Ste*_*non的帖子

假设我已经或即将编写一组相关函数.假设他们与数学有关.在组织上,我应该:

1. 编写这些函数并将它们放在我的MyMath命名空间中并通过它们引用它们MyMath::XYZ()
2. 创建一个名为的类MyMath,并将这些方法设为静态,并引用类似的方法MyMath::XYZ()

为什么我会选择一个作为组织我的软件的方法？

我刚刚听说iphone不能原生地加倍,从而使它们比常规漂浮慢得多.

这是真的？证据？

我对这个问题很感兴趣,因为我的程序需要高精度计算,而且我必须在速度上妥协.

在C#中有没有办法获得调用方法的程序集？(不是当前的方法.)

即我想要执行程序集,一个在调用堆栈中.

正如我所理解的那样,.net Framework中的汇编是中间语言文件+一些元数据,清单和其他东西.

CLR将程序集转换为机器代码,可以在给定的本地机器上执行.

这意味着在CLR处理之前,程序集不应该由程序集执行.如果是这样,那为什么它有.exe扩展名,可以在Windows机器上执行？

这是一个奇怪的我很困惑.我最近注意到在Gnu Octave提示符下,可以输入负零,如下所示:

octave:2> abomination = -0

它也记得它:

octave:3> abomination
abomination = -0

为了理智,负零确实等于常规零.但我也注意到这个标志还有一些其他的影响.像这些:

octave:6> 4 * 0
ans = 0
octave:7> 4 * -0
ans = -0
octave:8> 4 / 0
warning: division by zero
ans = Inf
octave:9> 4 / -0
warning: division by zero
ans = -Inf

可以看出,通过某些操作保留了标志.但我的问题是为什么.这似乎是对标准数学的彻底背离,其中零基本上没有符号.有这个有吸引力的数学属性吗？这在某些数学领域是否重要？

仅供参考:Matlab,以八度为模型,没有负零.任何使用它们的尝试都被视为常规零.

编辑:Matlab确实有负零,但它们不会显示在默认输出中.

我有一个应用程序,内部循环的一部分基本上是:

double sum = 0;
for (int i = 0; i != N; ++i, ++data, ++x) sum += *data * x;

如果x是unsigned int,那么代码需要3倍于int!

这是一个更大的代码库的一部分,但我把它归结为要点:

#include <iostream>                                      
#include <cstdlib>                                       
#include <vector>
#include <time.h>

typedef unsigned char uint8;

template<typename T>
double moments(const uint8* data, int N, T wrap) {
    T pos = 0;
    double sum = 0.;
    for (int i = 0; i != N; ++i, ++data) {
        sum += *data * pos;
        ++pos;
        if (pos == wrap) pos = 0;
    } …

我是LAPACK和C++/Fortran接口的初学者.我需要在Mac OS-X Lion上使用LAPACK/BLAS解决线性方程和特征值问题.OS-X Lion提供优化的BLAS和LAPACK库(在/ usr/lib中),我链接这些库而不是从netlib下载它们.

我的程序(下面转载)正在编译并运行正常,但它给了我错误的答案.我已经在Web和Stackoverflow上进行了研究,这个问题可能要处理C++和Fortran如何以不同的格式存储数组(行主要与列主要).但是,正如您将在我的示例中看到的那样,我的示例的简单数组在C++和fortran中应该看起来相同.无论如何这里去了.

让我们说我们要解决以下线性系统:

x + y = 2

x - y = 0

解是(x,y)=(1,1).现在我尝试使用Lapack解决这个问题,如下所示

// LAPACK test code

#include<iostream>
#include<vector>

using namespace std;
extern "C" void dgetrs(char *TRANS, int *N, int *NRHS, double *A, 
                      int *LDA, int *IPIV, double *B, int *LDB, int *INFO );

int main()
{
    char trans = 'N';
    int dim = 2;    
    int nrhs = 1;
    int LDA = dim;
    int LDB = dim;
    int info;

    vector<double> a, b;

    a.push_back(1);
    a.push_back(1);
    a.push_back(1); …

我正在对我之前从文件中读取的矩阵执行模板计算.我使用两种不同的矩阵(NonZero类型和Zero类型).两种类型共享边界的值(通常为1000),而其余元素对于零类型为0,对于NonZero类型为1.

代码将文件的矩阵存储在两个相同大小的分配矩阵中.然后,它使用自己的值和邻居值(添加x 4和mul x 1)在一个矩阵的每个元素中执行操作,并将结果存储在第二个矩阵中.一旦计算完成,交换矩阵的指针并且执行相同的操作有限次数.这里有核心代码:

#define GET(I,J) rMat[(I)*cols + (J)]
#define PUT(I,J) wMat[(I)*cols + (J)]

for (cur_time=0; cur_time<timeSteps; cur_time++) {
    for (i=1; i<rows-1; i++) {
        for (j=1; j<cols-1; j++) {
            PUT(i,j) = 0.2f*(GET(i-1,j) + GET(i,j-1) + GET(i,j) + GET(i,j+1) + GET(i+1,j));
        }
    }
    // Change pointers for next iteration
    auxP = wMat;
    wMat = rMat;
    rMat = auxP;
}

我暴露的情况使用固定量的500个timeSteps(外部迭代)和8192行和8192列的矩阵大小,但是在更改timeSteps或矩阵大小的数量时问题仍然存在.请注意,我只测量算法的这个具体部分的时间,因此从文件读取矩阵或其他任何因素都会影响时间度量.

它发生了什么,取决于我使用哪种类型的矩阵,我得到不同的时间,使用Zero类型时获得更差的性能(每隔一个矩阵执行与NonZero类型相同,因为我已经尝试生成一个充满随机的矩阵值).

我确定它是乘法运算,就像我删除它并只留下添加,它们执行相同的操作.注意,对于零矩阵类型,大多数类型的和的结果将为0,因此操作将为"0.2*0".

这种行为对我来说当然很奇怪,因为我认为浮点运算独立于操作数的值,这看起来不像这里的情况.我也尝试捕获并显示SIGFPE异常以防出现问题,但我没有得到任何结果.

如果有帮助,我使用的是Intel Nehalem处理器和gcc 4.4.3.

如何检查双x是否可以被C中的另一个双y整除？使用整数我只会使用模数,但是用双精度执行它的正确/最佳方法是什么？

我知道浮点数带有不精确性,但我从标准输入得到了双倍.也许我不应该直接扫描它,而是两个整数,但是从那时起我会去哪里？

我得到了一条由两点限制的线的斜率

float slopeXY(CGPoint p1, CGPoint p2)
{
    return ((p2.y - p1.y) / (p2.x - p1.x));
}

如果我给它一个零线,

CGPoint p1 = CGPointMake(0, 10);
CGPoint p2 = CGPointMake(0, 10);

float sxy = slopeXY(p1, p2);

我没有得到零除错误.