小编Mic*_*oek的帖子

这是我第一次使用SSE内在函数.我试图将一段简单的代码转换为使用英特尔SSE内在的更快的版本(直到SSE4.2).我好像遇到了一些错误.

代码的标量版本是:(简单矩阵乘法)

     void mm(int n, double *A, double *B, double *C)
     {
        int i,j,k;
        double tmp;

        for(i = 0; i < n; i++)
            for(j = 0; j < n; j++) {
                    tmp = 0.0;
                    for(k = 0; k < n; k++)
                            tmp += A[n*i+k] *
                                   B[n*k+j];
                    C[n*i+j] = tmp;

              }
            }

这是我的版本:我已经包含了 #include <ia32intrin.h>

      void mm_sse(int n, double *A, double *B, double *C)
      {
        int i,j,k;
        double tmp;
        __m128d a_i, b_i, c_i;

        for(i = 0; i < n; i++)
            for(j …

我在R中有一个向量,其中包含至少50.000个实数.值从小到大排序,现在我需要在不同的向量中分割这个向量.当两个数字之间的差异大于给定数量(比如两个)时,向量必须被分开.

例,

data <- c(1,1.1, 1.2, 4, 4.2, 8, 8.9, 9, 9.3);
# Then I need the following vectors:
x1 <- c(1, 1.1, 1.2);
x2 <- c(4, 4.2);
x3 <- c(8, 8.9, 9, 9.3);

困难在于我们不知道所需矢量的数量,并且不知道正确的每个矢量的长度.

现在我有了以下想法,但这非常耗时,它只能将矢量分成两个新的矢量.

j <- 2;
seqDemA1 <- seqDemandA[1];
while((seqDemandA[j-1] - seqDemandA[j] < 2) && (j < length(seqDemandA)+1)) {
    seqDemA1 <- c(seqDemA1, seqDemandA[j]);
    j <- j+1;
}
seqDemA2 <- seqDemandA[j];
j <- j+1;
while((seqDemandA[j-1] - seqDemandA[j] < 2) && (j < length(seqDemandA)+1)) {
    seqDemA2 <- c(seqDemA2, seqDemandA[j]); …

我正在尝试用Java实现Stoachastic Hill Climbing.据我所知,这个algorthim提出了一个新的解决方案,随机挑选,然后根据它的好坏来接受解决方案.例如,如果它非常糟糕,那么它将有一个很小的机会,如果它很糟糕,那么它将有更多的机会被选中,但我不知道如何在java中实现这个概率.

虽然在谷歌上浏览,我偶然发现了这个等式,

• f代表旧的健身
• f'代表新的健身
• T是一个参数

我不太确定如何解释这个等式.

有人可以帮助我如何在Java中实现这一点吗？

Scott Mayers的"Effective Modern C++"中的第13项声明更喜欢const_iterator而不是迭代器.我同意,但我也想使用非成员函数而不是成员函数.根据这本书,应该有一个非成员函数std::cbegin()和std::cend()C++ 14.

为了利用这个功能,我刚刚安装了gcc版本4.9.2并使用该标志进行了编译-std=c++14.它似乎编译,直到我尝试使用std::cbegin().我开始寻找对此功能的支持,但无法找到任何相关信息.例如,在gnu onlinedocs状态下,甚至没有提到该功能.

我的问题是,将在c ++ 14中支持std::cbegin()并std::cend()真正得到支持,还是这本书中的错误？如果它是C++ 14的特性,是否有已经支持这些功能的编译器以及gcc什么时候支持它？

在SO上有很多问题,begin()但这些问题是关于成员函数或关于constexpr-ness而不是关于非成员变体的支持.

我们刚开始在C++ 11中学习模板元编程.作为练习,我们编写了一个程序,输出int值的二进制表示.我们想出了两个可能的实现.第一个使用带有枚举值的递归,而第二个方法使用constexpr函数.

我们的期望是两个实现都会产生相同大小的可执行文件.但是,第一个实现导致9064字节,而第二个实现9096字节.我们不介意字节上的微小差异,但不明白导致差异的原因.

我们使用GCC 4.8.2编译了没有优化标志的程序,但是,找到了相同的结果-O2标志.

#include <iostream>
using namespace std;

template <int val>
struct Bin
{
    enum { value = 10 * Bin<(val >> 1)>::value + (val & 1) };
};

template <>
struct Bin<0>
{
    enum { value = 0 };
};

constexpr int bin(int val)
{
  return val == 0 ? 0 : (10 * bin(val >> 1) + (val & 1));
}


int main()
{
  // Option 1
  cout << Bin<5>::value  << '\n'
       << Bin<27>::value << '\n'; …

我有一个未分类的双精度矢量(实际上是带有双成员的对象,在这种情况下使用).从这个向量我需要删除最小的非唯一值.但是,不保证存在非唯一值.允许对范围进行排序.

一如既往,我开始寻找std :: algorithm并找到std :: unique.在我的第一个想法中,我将结合使用std :: sort将所有非唯一值移动到向量的末尾,然后在非唯一值上使用min_element.但是,std :: unique会将非唯一值保留在未指定状态的末尾.事实上,我失去了所有非POD成员.

有没有人有建议如何有效地做到这一点？由于代码在程序的瓶颈中使用(已经有点太慢),因此有效地执行它非常重要.

我现在正在从C转换到C++ 11,我尝试了解有关转换的更多信息.在这个问题的最后,你会看到一个小程序,它将一个数字作为输入,然后将其显示为数字和字符.然后它被转换为char,之后我将它转换回size_t.

当我输入200作为输入时,第一个cout打印200,但第二个cout打印18446744073709551560.如何让它再次打印200？我使用错误的演员吗？我已经尝试过不同的演员作为动态和重新演绎.

#include<iostream>

using namespace std;

int main(){  
  size_t value;

  cout << "Give a number between 32 and 255: ";
  cin >> value;

  cout << "unsigned value: " << value << ", as character: `" << static_cast<char>(value) << "\'\n";

  char ch = static_cast<char>(value);
  cout << "unsigned value: " << static_cast<size_t>(ch) << ", as character: `"  << ch << "\'\n";
}

我想显示右边距和下边距,但不是两者的组合.这可能与facet_grid一起使用吗？

library(ggplot2)

ggplot(mtcars, aes(x = hp, group = vs)) + 
  geom_density() + 
  facet_grid(am ~ vs, switch = "y", margins = TRUE) 

我试图通过手动为margin参数提供因素来修复它,但这没有帮助.此外,R文档对我没有帮助.

目前的结果

期望的结果

我需要a中最小值的索引vector<int>,但是只有一些索引必须考虑在内.说我们有:

vector<int> distance({5, 5, 4, 3, 5});
vector<int> neighbors({0, 1, 2, 4});

然后不考虑值3,因此4是最小值,因此我需要索引2.可以通过向未考虑的值添加大常量来解决它:

int City::closest(set<int> const &neighbors) const
{
  vector<double> dist(d_distance);
  for (size_t idx = 0; idx != dist.size(); ++idx)
  {
    auto it = find(neighbors.begin(), neighbors.end(), idx);
    if (it == neighbors.end())
      dist[idx] = __INT_MAX__;
  }

  auto min_el = min_element(dist.begin(), dist.end());
  return distance(dist.begin(), min_el);
}

但是我认为这种方法不可读,我更喜欢STL算法或其中两种的组合.你有一个更整洁的解决方案吗？

我有一个带有双精度的向量，我想对其进行排名（实际上它是一个带有带有名为 的双精度成员的对象的向量costs）。如果只有唯一值或者我忽略非唯一值，那么就没有问题。但是，我想对非唯一值使用平均排名。此外，我在 SO 上发现了一些关于排名的问题，但是他们忽略了非唯一值。

例如，假设我们有 (1, 5, 4, 5, 5)，那么相应的排名应该是 (1, 4, 2, 4, 4)。当我们忽略非唯一值时，排名为 (1, 3, 2, 4, 5)。

当忽略非唯一值时，我使用了以下内容：

void Population::create_ranks_costs(vector<Solution> &pop)
{
  size_t const n = pop.size();

  // Create an index vector
  vector<size_t> index(n);
  iota(begin(index), end(index), 0);

  sort(begin(index), end(index), 
       [&pop] (size_t idx, size_t idy) { 
         return pop[idx].costs() < pop[idy].costs();
       });

  // Store the result in the corresponding solutions
  for (size_t idx = 0; idx < n; ++idx)
    pop[index[idx]].set_rank_costs(idx + 1);
}

有谁知道如何考虑非唯一值？我更喜欢使用，std::algorithm因为在我看来，这会带来干净的代码。

我只想使用单个循环来反转字符串。我该怎么做？我尝试了一种简单的方法，但没有得到我想要的输出。

#include<iostream>
using namespace std;

int main()
{
    int i;
    char a[10];

    cout << " Enter String :";
    cin >> a;

    for(a[i] = '\0'; i > 0; i--)
    {   
        cout << "Reverse string is" << a[i];
    }

    return 0;
}