小编and*_*dge的帖子

我有一个关于在c ++ 11中定义向量的新快捷方式的问题.假设我有以下课程

struct Tester{

  vector< vector<int> > data;

  Tester(){
    data = vector< vector<int> >();
  }

  void add(vector<int> datum){
    data.push_back(datum);
  }

};

然后,以下按预期工作:

int main(){
    Tester test = Tester();
    vector<int> datum = vector<int>{1,2,3};
    test.add(datum);
}

但这不是:

int main(){
    Tester test = Tester();
    test.add(vector<int>{1,2,3});
}

有人可以向我解释一下这个区别吗？如何在第二个main()中执行我尝试的快捷方式？

我有一个基类,然后是几个派生类.我想为这些派生类重载"<<"运算符.对于普通算子,即'+',虚函数可以解决问题.我所理解的标准惯例是宣布

friend ostream& operator<<(ostream& out, MyClass& A);

在我的课程中,然后在课程后定义函数.先验我认为将虚拟添加到上面的定义会使它工作,但经过一些思考(和编译器的错误)我意识到这没有多大意义.

我在一个测试用例上尝试了不同的方法,所有的类成员都是公开的.例如:

class Foo{
 //bla
};

ostream& operator<<(ostream& out, Foo& foo){
  cout << "Foo" << endl;
  return foo;
}

class Bar : public Foo{
 //bla
};

ostream& operator<<(ostream& out, Bar& bar){
  cout << "Bar" << endl;
  return bar;
}

///////////////////////

Bar bar = Bar();
cout << bar << endl; // outputs 'Foo', not 'Bar' 

所以在某种程度上这是"多态变坏" - 基类运算符<<被调用而不是派生类运算符.在上面的例子中,如何为派生类调用正确的运算符？更一般地说,如果我的班级有我想要保护的私人成员,我怎样才能在使用friend关键字时纠正运算符重载？

我正在尝试在python中找出多线程编程.这是我想要比较串行和并行速度的简单任务.

import threading
import Queue
import time
import math

def sinFunc(offset, n):
  result = []
  for i in range(n):
    result.append(math.sin(offset + i * i))
  return result

def timeSerial(k, n):
  t1 = time.time()    
  answers = []
  for i in range(k):
    answers.append(sinFunc(i, n))
  t2 = time.time()
  print "Serial time elapsed: %f" % (t2-t1)

class Worker(threading.Thread):

  def __init__(self, queue, name):
    self.__queue = queue
    threading.Thread.__init__(self)
    self.name = name

  def process(self, item):
    offset, n = item
    self.__queue.put(sinFunc(offset, n))
    self.__queue.task_done()
    self.__queue.task_done()

  def run(self):
    while 1:
        item …

我想知道在java(纯代码,而不是一些Eclipse的东西)中是否有一种方法可以将"语法糖"重复尝试捕获代码.也就是说,我必须包装一堆函数

public void foo(){
  try{
        // bla
  } catch (Exception e) {
            System.out.println("caught exception:");
            e.printStackTrace();
  }
}

public void bar(){
  try{
        // other bla
  } catch (Exception e) {
            System.out.println("caught exception:");
            e.printStackTrace();
  }
}

等等.我想写

@excepted public void foo(){
// bla
}

@excepted public void bar(){
// other bla
}

我认为这种类型的糖在python中是可能的.在Java中有可能吗？

我打算参加MIT的battlecode比赛.参赛者编写的程序可以控制相互对抗的机器人.问题在于你的机器人仅限于在一个回合中执行一定数量的字节码(去年每回合10000次).现在,简单的循环就像

(int i=0; i<100; i++){
// do nothing
}

根据他们的软件,使用大约400字节码(大概是这样的(用于递增i的2字节码加上用于检查i <100的2字节码)*100 = 400字节码)因此我们必须编写非常紧密的代码.因此,当我尝试一些不同的导航算法时,重要的是我能够弄清楚我的代码使用了多少字节码 - 我该怎么做？

(这是可能的 - 他们这样做,我只是不确定如何!而且,他们必须阻止JIT以某种方式进入游戏.我知道每个机器人都在一个单独的线程中运行,所以我肯定答案涉及到一些我不知道的线程技巧.)

有人设法在Vowpal Wabbit中运行普通的最小二乘回归吗？我试图确认它将返回与确切解决方案相同的答案,即当选择最小化||y - X a||_2 + ||Ra||_2(其中R是正则化)时,我想得到分析答案 a = (X^T X + R^T R)^(-1) X^T y.在numpy python中进行这种类型的回归需要大约5行.

大众的文档表明它可以做到这一点(可能是"平方"的损失函数),但到目前为止,我还是无法让它接近匹配python结果.因为平方是默认的损失函数,我只是简单地称:

$ vw-varinfo input.txt

其中input.txt有像这样的行

1.4 | 0:3.4 1:-1.2 2:4.0  .... etc

我还需要大众电话中的其他参数吗？我无法理解(相当简单的)文档.

我正在使用C++中的线程,特别是使用它们来并行化地图操作.

这是代码:

#include <thread>
#include <iostream>
#include <cstdlib>
#include <vector>
#include <math.h>
#include <stdio.h>

double multByTwo(double x){
  return x*2;
}

double doJunk(double x){
  return cos(pow(sin(x*2),3));
}

template <typename T>
void map(T* data, int n, T (*ptr)(T)){
  for (int i=0; i<n; i++)
    data[i] = (*ptr)(data[i]);
}

template <typename T>
void parallelMap(T* data, int n, T (*ptr)(T)){
  int NUMCORES = 3;
  std::vector<std::thread> threads;
  for (int i=0; i<NUMCORES; i++)
    threads.push_back(std::thread(&map<T>, data + i*n/NUMCORES, n/NUMCORES, ptr));
  for (std::thread& t : threads)
    t.join();
}

int …

我正在编写一些需要在内存中保存大量数据的"大数据"软件.我用c ++写了一个非常好的原型.然而,实际的最终用户通常使用Java编写代码,因此他们要求我也编写Java原型.

我已经完成了java中内存占用的背景阅读和一些初步测试.例如,假设我有这个对象

public class DataPoint{

    int cents, time, product_id, store_id;

    public DataPoint(int cents, int time, int product_id, int store_id){
    this.cents = cents;
    this.time = time;
    this.product_id = product_id;
    this.store_id = store_id;
    }
}

在C++中,这个结构的大小是16个字节,这是有道理的.在Java中,我们必须是间接的.如果我创建了例如10m的这些对象并使用Runtime.totalMemory() - Runtime.freeMemory()之前和之后然后根据需要进行除法,每个结构大约需要36个字节.一个~2.4倍的内存差异非常讨厌; 当我们试图在内存中保存数亿个DataPoints时,它会变得丑陋.

我在某处看到,在Java中这样的情况下,将数据存储为数组更好 - 实质上是基于列的存储而不是基于行的存储.我想我理解这一点:基于列的方式减少了引用数量,也许JVM甚至可以智能地将整数打包成8字节的字.

我可以使用哪些其他技巧来减少内存占用的内存占用内存块,该内存块具有一个非常大的维度(数百万/数十亿的数据点)和一个非常小的维度(O(1)列数/变量)？

结果是将数据存储为4个int数组,每个条目恰好使用16个字节.经验教训:小对象在java中具有令人讨厌的比例开销.

我试图了解如何在c ++中使用带有对象的互斥锁.我有以下(普通的)多线程代码我用作速度测试:

 struct Rope{
   int n, steps, offset;
   //std::mutex mut;

   Rope() {}
   Rope(int n, int steps, int offset) : n(n), steps(steps), offset(offset) {}

   void compute(){
     double a[n];
     for (int i=0; i<n; i++)
       a[i] = i + offset;
     for (int step=0; step<steps; step++)
       for (int i=0; i<n; i++)
     a[i] = sin(a[i]);
   }

 };

 void runTest(){
   int numRuns = 30;
   int n = 10000;
   int steps = 10000;

   std::vector<Rope> ropes;
   std::vector<std::thread> threads;
   for (int i=0; i<numRuns; i++)
     ropes.push_back(Rope(n, steps, i));
   for (auto& …

我正在运行一些代码,可能指出我不太了解堆和堆栈之间的区别.下面我有一些示例代码,我要么在堆栈上声明一个数组,要么在1234567元素的堆上声明一个数组.两者都有效.

int main(int argc, char** argv){

  int N = 1234567;

  int A[N];

  //int* A = new int[N];

}

但是如果我们将N设为12345678,我会得到一个带有int A [N]的seg错误,而堆声明仍然可以正常工作.(如果重要的话,我正在使用g ++ O3 -std = c ++ 0x).这有什么疯狂的？堆栈是否有(相当小的)数组大小限制？