小编Tho*_*oth的帖子

所以我正在使用Google自定义搜索(Google CSE),我正在尝试使用优化功能将搜索查询重定向到Google学术搜索.

基本上我正在遵循这里找到的文档.然而事实证明,尽管有文档,但这个功能并不存在,并且Google似乎没有计划在不久的将来实现它(请参阅此处的StackOverflow帖子).

我的问题是,是否有人针对此问题进行了黑客/解决方法,以便我可以使用Google CSE搜索Google学术搜索？

所以我用Python和Julia编写了一个Eratosthenes函数的小筛子,我正在比较运行时间.

这是Python代码:

import time

def get_primes(n):
    numbers = set(range(n, 1, -1))
    primes = []
    while numbers:
        p = numbers.pop()
        primes.append(p)
        numbers.difference_update(set(range(p*2, n+1, p)))
    return primes

start = time.time()
get_primes(10000)
print time.time() - start

这是朱莉娅代码:

function get_primes(n)
        numbers = [2:n]
        primes = Int[]
        while numbers != []
                p = numbers[1]
                push!(primes, p)
                numbers = setdiff(numbers, [p*i for i=1:int(n/p)])
        end
        return primes
end

@time get_primes(10000);

Python代码在大约.005秒内运行,而Julia代码大约需要0.5秒,因此这意味着Python运行速度大约快100倍.这可能是一个完全合乎逻辑的原因,但我真的不知道我在做什么.

所以我在Python中有一些神经网络代码,我在Julia中重写了这些代码.直接的Python代码在大约7秒内运行,而Julia和PyPy代码在大约0.75秒内运行

sigmoid(z::Float64) = 1/(1 + exp(-z))
sigmoidPrime(z::Float64) = sigmoid(z) * (1 - sigmoid(z))

### Types ###

abstract AbstractNode

type Edge
    source::AbstractNode
    target::AbstractNode
    weight::Float64
    derivative::Float64
    augmented::Bool

    Edge(source::AbstractNode, target::AbstractNode) = new(source, target, randn(1,1)[1], 0.0, false)
end

type Node <: AbstractNode
    incomingEdges::Vector{Edge}
    outgoingEdges::Vector{Edge}
    activation::Float64
    activationPrime::Float64

    Node() = new([], [], -1.0, -1.0)
end

type InputNode <: AbstractNode
    index::Int
    incomingEdges::Vector{Edge}
    outgoingEdges::Vector{Edge}
    activation::Float64

    InputNode(index::Int) = new(index, [], [], -1.0)
end

type BiasNode <: AbstractNode
    incomingEdges::Vector{Edge}
    outgoingEdges::Vector{Edge}
    activation::Float64

    BiasNode() = new([], [], 1.0)
end

type Network
    inputNodes::Vector{InputNode} …

我给了表格的功能

f(;a=1, b=2, c=3, d=4) = ...

以及长度为4的向量,其中包含指示需要输入哪些关键字参数的布尔值,然后还有一个长度在1到4之间的向量,以便在相应的槽中输入(按顺序).例如,我可能会被给予

[true,false,true,false]
[5,100]

那么我想要以下评估:

f(a=5, c=100)

我如何高效优雅地完成这项工作？

假设我有代码，

try
    throw(ArgumentError("hi"))
catch 
    println("something went wrong")
    throw(ArgumentError("bye"))
end

运行此代码会产生以下输出

something went wrong
ERROR: ArgumentError: bye
Stacktrace:
 [1] top-level scope at REPL[31]:5
caused by [exception 1]
ArgumentError: hi
Stacktrace:
 [1] top-level scope at REPL[31]:2

基本上，它同时抛出try块中的错误和块中的错误catch。

我对事情应该如何工作的理解是try应该失败，然后它应该简单地输出catch块内的内容。

任何人都可以解释这里发生了什么，以及如何重写此代码以使其具有所需的功能。

谢谢。

我正在编写一个 OpenCL 内核，它将涉及解决一个线性系统。目前我的内核太慢了，提高线性系统部分的性能似乎是一个很好的起点。

我还应该注意，我并不是要让我的线性求解器平行，我正在处理的问题在宏观层面上已经令人尴尬地平行了。

以下是我为使用部分旋转的高斯消元法求解 Ax=b 而编写的 C 代码，

#import <stdio.h>
#import <math.h>
#import <time.h>

#define K 50

// Solve the system Ax=b using Gaussian elimination with partial pivoting.
void linear_solve(float A[K * K], float b[K])
{
    for (long j=0; j<K; j++)
    {
        // Begin partial pivoting.
        float maxval = fabs(A[K * j + j]);

        long maxrow = j;

        for (long i=j+1; i<K; i++)
        {
            if (fabs(A[K * j + i]) > maxval)
            {
                maxval = fabs(A[K * j + …