如果我的库的用户尝试使用不合适的类型实例化模板,我试图触发编译时错误.我实施了:
template <typename T>
struct good_type { enum { value = false }; };
template <>
struct good_type<string> { enum { value = true }; };
template <>
struct good_type<int64_t> { enum { value = true }; };
template <typename T>
struct X
{
BOOST_STATIC_ASSERT(good_type<T>::value);
};
int main(int argc, char** argv)
{
X<string> x1;
X<int64_t> x2;
X<float> x3;
return 0;
}
这是有效的,但我从gcc得到的消息有点令人惊讶:
error: invalid application of 'sizeof' to incomplete type 'boost::STATIC_ASSERTION_FAILURE<false>'
我应该使用不同的Boost宏吗？有一个更好的方法吗？
谢谢!
我需要使用geo.cca mapin a 中的键进行选择DataFrame：
|-- params: map (nullable = true)
| |-- key: string
| |-- value: string (valueContainsNull = true)
但是键的值，中间有一个点，似乎混淆了 Spark。如果我写：
X.filter(X("params.geo.cc") === "us")
我收到错误：
org.apache.spark.sql.AnalysisException: Can't extract value from params#3[geo];
我能做什么？（不用说，我不控制键，即我不能将该geo.cc字符串更改为例如geo_cc.
我用numpy和我自己的代码计算NPV,结果不同.我必须在某处犯错.任何指针？
// Solution 1
r = .06
flows = {0:1200, 3:-450, 6:-450, 15:-450}
print sum([C/(1+r)**i for i,C in flows.iteritems()])
// => 317
// Solution using numpy's npv function
flows = zeros(16)
flows[0] = 1200
flows[3] = -450
flows[6] = -450
flows[15]= -450
print np.npv(r, flows)
// => 299
我正在看:
ld: in objs/AttributeValueTest.o, can't link with a main executable for architecture x86_64
构建一个只有1 .h和1 .cpp文件的非常简单的程序时.
编译行是:
g++ -g -I./ -I/usr/local/include -o objs/AttributeValueTest.o tp_datastruct/tests/AttributeValueTest.cpp -L/usr/local/lib -lavrocpp -lcppunit -lm
g++ -g -I./ -I/usr/local/include -o AttributeValueTest objs/AttributeValueTest.o -L/usr/local/lib -lavrocpp -lcppunit -lm
我试图指定-arch x86_64,-arch i386和-m32,但没有任何效果(我有其他错误,它抱怨libcppunit的格式不正确).
任何想法/指针/建议？
谢谢!
很奇怪.我做了一些挖掘,并看到了某个地方,AttributeValueTest.o可能已经是一个可执行文件.我在AttributeValueTest.o上做了一个"文件",果然,它是一个随时可用的可执行文件.我修改了我的makefile,将.o重命名为AttributeValueTest,我很乐意运行它.此外,可执行文件附带一个".dSYM"目录,我可以删除没有任何问题...我不明白发生了什么,但我现在可以运行我的可执行文件...
可能重复:
java中是否有内联函数？
我来自C++,我会写
for (int i = 0; i < numNonZero(); ++i)
知道numNonZero(),非常小,"内联"只会从编译后的代码中消失.在Java中怎么样？我应该在我的班级中有一个int _numNonZero并写
for (int i = 0; i < _numNonZero; ++i)
为了最大速度？
我有一个通用的Python memoizer:
cache = {}
def memoize(f):
"""Memoize any function."""
def decorated(*args):
key = (f, str(args))
result = cache.get(key, None)
if result is None:
result = f(*args)
cache[key] = result
return result
return decorated
它有效,但我对它不满意,因为有时效率不高.最近,我使用了一个将列表作为参数的函数,显然用整个列表制作键会减慢一切.最好的方法是什么？(即,有效地计算密钥,无论args是什么,无论它们是多长还是复杂)
我想这个问题实际上是关于如何从args和泛型memoizer的函数有效地生成密钥 - 我在一个程序中观察到,糟糕的密钥(生成成本太高)对运行时产生了重大影响.我的编程用'str(args)'拍摄了45秒,但我可以用手工制作的键将其减少到3秒.不幸的是,手工制作的密钥是特定于这个编程,但我想要一个快速的记事本,我不必每次都为缓存推出特定的,手工制作的密钥.
我正在寻找模板代码来对模板参数进行排序,例如:
template <typename T, typename ... Args>
list<T> sort(T first, Args ... rest)
Args中的所有类型实际上都是T,但我需要使用可变参数模板,这样我可以编写小的编译时间列表:
sort(varA, varB, varC, varD).
(事实上,我计划有一个"all_different",它会排序和删除重复项,以评估4个值varA,varB,varC,varD是否都不同).
哪个地方已经写过了？
我试图定义一个类型特征,我可以static_assert用来控制我的一个模板类只用s实例化td::array<T,n>.这是我的尝试:
template <typename T>
struct is_std_array : public false_type {};
template <template <typename, size_t> class T, typename V, size_t n>
struct is_std_array<std::array<V, n>> : public true_type {};
但我从clang得到以下警告:
warning: class template partial specialization contains a template parameter
that cannot be deduced; this partial specialization will never be used
non-deductible template parameter 'T'
为什么'T'不能扣除？我该如何解决这个问题？
我试图评估哪种数据结构最能代表Scala中的稀疏向量.这些稀疏向量包含索引列表,每个索引包含一个值.我实现了一个小的基准测试,这似乎表明Array[(Long, Double)]似乎比2个并行数组占用的空间要少得多.那是对的吗？我正确地做了那个基准吗？(如果我在某处做错了,我不会感到惊讶)
import java.lang.management.ManagementFactory
import java.text.NumberFormat
object TestSize {
val N = 100000000
val formatter: NumberFormat = java.text.NumberFormat.getIntegerInstance
def twoParallelArrays(): Unit = {
val Z1 = Array.ofDim[Long](N)
val Z2 = Array.ofDim[Double](N)
Z1(N-1) = 1
Z2(N-1) = 1.0D
println(Z2(N-1) - Z1(N-1))
val z1 = ManagementFactory.getMemoryMXBean.getHeapMemoryUsage.getUsed
val z2 = ManagementFactory.getMemoryMXBean.getNonHeapMemoryUsage.getUsed
println(s"${formatter.format(z1)} ${formatter.format(z2)}")
}
def arrayOfTuples(): Unit = {
val Z = Array.ofDim[(Long, Double)](N)
Z(N-1) = (1, 1.0D)
println(Z(N-1)._2 - Z(N-1)._1)
val z1 = ManagementFactory.getMemoryMXBean.getHeapMemoryUsage.getUsed
val z2 = ManagementFactory.getMemoryMXBean.getNonHeapMemoryUsage.getUsed
println(s"${formatter.format(z1)} ${formatter.format(z2)}") …我有一个二进制最大堆(顶部的最大元素),我需要保持它的常量(比如说20个元素),每次我得到20个元素时去掉最小的元素.二进制堆存储在一个数组中,节点i的子节点为2*i和2*i + 1(i基于零).在任何时候,堆都有'n_elements'元素,介于0和20之间.例如,数组[16,14,10,8,7,9,3,2,4]将是一个有效的最大二进制堆, 16岁有14岁和10岁的孩子,14岁有8岁和7岁的孩子......
为了找到最小的元素,似乎通常我必须遍历从n_elements/2到n_elements的数组:最小元素不一定是数组中的最后一个元素.
因此,仅使用该数组,似乎任何寻找/移除最小elt的尝试都至少为O(n).那是对的吗？