小编k1n*_*ext的帖子

我想有一个抽象类，它强制每个派生类在其__init__方法中设置某些属性。

我已经看了几个不能完全解决我问题的问题，特别是在这里或这里。这看起来很有希望，但我无法使其正常运行。

我假设我想要的结果可能类似于以下伪代码：

from abc import ABCMeta, abstractmethod


class Quadrature(object, metaclass=ABCMeta):

    @someMagicKeyword            #<==== This is what I want, but can't get working
    xyz

    @someMagicKeyword            #<==== This is what I want, but can't get working
    weights


    @abstractmethod
    def __init__(self, order):
        pass


    def someStupidFunctionDefinedHere(self, n):
        return self.xyz+self.weights+n



class QuadratureWhichWorks(Quadrature):
    # This shall work because we initialize xyz and weights in __init__
    def __init__(self,order):
        self.xyz = 123
        self.weights = 456

class QuadratureWhichShallNotWork(Quadrature):
    # …

Donzis&Aditya的一篇论文表明,有可能使用可能在模板上有延迟的有限差分方案.这是什么意思？FD方案可能用于解决热方程和读取(或简化它)

u[t+1,i] = u[t,i] + c (u[t,i-1]-u[t,i+1])

意思是,下一个时间步的值取决于同一位置的值及其前一时间步的邻居.

通过将(在我们的示例中为1D)域分割到不同的处理器上,可以容易地将该问题平行化.但是,在计算处理器的边界节点时我们需要通信,因为该元素u[t,i+-1]仅在另一个处理器上可用.

问题在下图中说明,该图取自引用的论文.

MPI实现可能使用MPI_Send和MPI_Recv进行同步计算.由于计算本身相当容易,因此通信可能成为可能的瓶颈.

该论文给出了该问题的解决方案:

尽管它可能是较早时间步长的值,但只需获取可用的边界音符而不是同步过程.然后该方法仍然收敛(在某些假设下)

对于我的工作,我想实现异步MPI案例(这不是本文的一部分).同步部件使用MPI_Send并且MPI_Recv工作正常.我将内存扩展了两个元素作为相邻元素的ghost单元格,并通过发送和接收发送所需的值.下面的代码基本上是上图的实现,并且在计算之前的每个时间步骤期间执行.

MPI_Send(&u[NpP],1,MPI_DOUBLE,RIGHT,rank,MPI_COMM_WORLD);
MPI_Recv(&u[0],1,MPI_DOUBLE,LEFT,LEFT,MPI_COMM_WORLD,MPI_STATUS_IGNORE);

MPI_Send(&u[1],1,MPI_DOUBLE,LEFT,rank,MPI_COMM_WORLD);
MPI_Recv(&u[NpP+1],1,MPI_DOUBLE,RIGHT,RIGHT,MPI_COMM_WORLD,MPI_STATUS_IGNORE);

现在,我绝不是MPI专家.我想,这MPI_Put可能是我需要的异步情况和阅读一点,我想出了以下实现.

在时间循环之前:

MPI_Win win;
double *boundary;
MPI_Alloc_mem(sizeof(double) * 2, MPI_INFO_NULL, &boundary);
MPI_Info info;
MPI_Info_create(&info);
MPI_Info_set(info,"no_locks","true");
MPI_Win_create(boundary, 2*sizeof(double), sizeof(double), info, MPI_COMM_WORLD, &win);

在时间循环内:

MPI_Put(&u[1],1,MPI_DOUBLE,LEFT,1,1,MPI_DOUBLE,win);
MPI_Put(&u[NpP],1,MPI_DOUBLE,RIGHT,0,1,MPI_DOUBLE,win);
MPI_Win_fence(0,win);
u[0] = boundary[0];
u[NpP+1] = boundary[1];

它将所需的元素放在窗口中,即boundary(具有两个元素的数组)在相邻的处理器上u[0]并u[NpP+1]从boundary数组本身获取值.这个实现工作正常,我得到了相同的结果MPI_Send/Recv.但是,由于我还在使用MPI_Win_fence,这并不是真正的异步,据我所知,这确保了同步.

问题是:如果我取出MPI_Win_fence里面的值boundary永远不会更新并保持初始值.我的理解是,如果没有MPI_Win_fence …

给出一个矢量

A = [1,2,3,...,100]

我想提取所有元素,除了每个第n个.所以,对于n = 5,我的输出应该是

B = [1,2,3,4,6,7,8,9,11,...]

我知道你可以访问每个第n个元素

A(5:5:end)

但我需要像逆命令这样的东西.如果这不存在,我将迭代元素并跳过每个第n个条目,但这将是肮脏的方式.

我想将uncrustify(通过美化Atom编辑器和配置文件)应用于CUDA代码.但是,我不知道如何告诉uncrustify识别具有以下结构的CUDA内核调用:

kernelName <<<N,M>>> (arg0,arg1,...);

然而,解决问题<<< >>>并且应用它会产生以下不愉快的结果

kernelName << < N, M >> >
    (arg0,arg1,...);

我想让它看起来更像一个函数调用,也避免格式化<<<为<< <.理想情况下,结果看起来像

kernelName <<< N, M >>> (arg0,arg1,
      ...); // line break if argument list is too long

我可以添加哪些参数config.cfg来实现上述结果？

非常感谢你.

我有一个数据集，作为 CSV 格式的要点上传到这里。它是 YouGov 文章“‘好’有多好？”中提供的 PDF 的提取形式。. 被要求用 0（非常负面）和 10（非常正面）之间的分数对单词（例如“完美”、“糟糕”）进行评分的人。要点正好包含该数据，即对于每个单词（列：单词），它为从 0 到 10（列：类别）的每个排名存储投票数（列：总计）。

我通常会尝试使用 matplotlib 和 Python 来可视化数据，因为我缺乏 R 方面的知识，但似乎 ggridges 可以创建比我使用 Python 所做的更好的绘图。

使用：

library(ggplot2)
library(ggridges)

YouGov <- read_csv("https://gist.githubusercontent.com/camminady/2e3aeab04fc3f5d3023ffc17860f0ba4/raw/97161888935c52407b0a377ebc932cc0c1490069/poll.csv")

ggplot(YouGov, aes(x=Category, y=Word, height = Total, group = Word, fill=Word)) + 
  geom_density_ridges(stat = "identity", scale = 3)

我能够创建这个图（仍然远非完美）：

忽略我必须调整美学的事实，我很难做到三件事：

1. 按单词的平均排名对单词进行排序。
2. 按平均等级为山脊着色。
3. 或按类别值为脊着色，即使用不同的颜色。

我试图调整来自这个来源的建议，但最终失败了，因为我的数据似乎格式错误：我已经有了每个类别的汇总投票数，而不是单一的投票实例。

我希望最终得到一个更接近这个情节的结果，它满足标准 3（来源）：

我是极地新手，不确定我是否.with_columns()正确使用。

这是我经常遇到的情况：有一个数据框，在其中.with_columns()，我对列应用一些操作。例如，我将一些日期转换为str类型date，然后想要计算开始日期和结束日期之间的持续时间。我将按如下方式实现这一点。

import polars as pl 

pl.DataFrame(
    {
        "start": ["01.01.2019", "01.01.2020"],
        "end": ["11.01.2019", "01.05.2020"],
    }
).with_columns(
    [
        pl.col("start").str.strptime(pl.Date, fmt="%d.%m.%Y"),
        pl.col("end").str.strptime(pl.Date, fmt="%d.%m.%Y"),
    ]
).with_columns(
    [
        (pl.col("end") - pl.col("start")).alias("duration"),
    ]
)

首先，我转换两列，然后.with_columns()再次调用。

像这样更短的东西是行不通的：

pl.DataFrame(
    {
        "start": ["01.01.2019", "01.01.2020"],
        "end": ["11.01.2019", "01.05.2020"],
    }
).with_columns(
    [
        pl.col("start").str.strptime(pl.Date, fmt="%d.%m.%Y"),
        pl.col("end").str.strptime(pl.Date, fmt="%d.%m.%Y"),
        (pl.col("end") - pl.col("start")).alias("duration"),
    ]
)

有没有办法避免调用.with_columns()两次并以更紧凑的方式编写？

我承认是朱莉娅的新手。但是，查看各种文档后，我找不到我的（可能很简单）问题的合适答案。

我从 Matlab 中了解到的

考虑src/名为main.m和的文件夹中的两个文件anotherfunc.m

function main
 anotherfunc(0)
end

和

function anotherfunc(x)
 disp(sin(x))
end

我会main在命令窗口中运行并查看所需的结果 ( =0)。现在，也许我改变主意并更喜欢

function otherfunc(x)
 disp(cos(x))
end

我再跑main看看1。

我不知道 Julia 如何做完全相同的事情。我尝试了两种我认为有效的方法。

1)

这些文件是anotherfunc.jl：

function anotherfunc(x)
 print(sin(x))
end

和（在同一目录中）main.jl：

function main()
 anotherfunc(0)
end

现在我julia在终端开始写

julia> include("anotherfunc.jl")
anotherfunc (generic function with 1 method)

julia> include("main.jl")
main (generic function with 1 method)

julia> main()
0.0

好的。现在我改sin到cos和GET

julia> …

在 Julia v1.01 中，我想从字符串创建一个函数。

背景：在数值求解器中，测试用例是通过 JSON 文件定义的。如果用户可以以字符串形式指定初始条件，那就太好了。

这会导致以下情况：假设我们有（来自 JSON 文件）

fcn_as_string = "sin.(2*pi*x)" 

有没有办法将其转换为function fcn我可以调用的

fcn(1.0) # = sin.(2*pi*1.0)

性能并不是真正的问题，因为初始条件被评估一次，然后实际计算消耗了大部分时间。

我对FastAPI大多数async相关功能都很陌生，因此我有可能同时犯下多个失礼行为；任何帮助表示赞赏。

我想提供一个公开一些功能的 API，例如将较低的字符串转换为较高的字符串（对于此 MWE）。我不想立即计算每个单独的请求，而是想填充一个缓冲区，并且仅在该缓冲区已满时才进行计算。这可能是因为它更便宜（计算上或美元方面）并且我对引入的延迟感到满意。

我尝试了以下实现

from fastapi import FastAPI
import asyncio
from typing import Dict

N = 2

app = FastAPI()
app.state.requests = []
app.state.answers = []
app.state.state = "start"


@app.get("/upper/")
async def upper(x: str) -> Dict[str, str]:
    myid = len(app.state.requests)
    app.state.requests.append(x)

    if len(app.state.requests) == N:
        app.state.answers = []
        for i in range(len(app.state.requests)):
            app.state.answers.append(app.state.requests[i].upper())
        app.state.state = "computed"
    else:
        await block_compute()

    myanswer = app.state.answers[myid]

    if len(app.state.requests) == N:
        app.state.answers = []
        app.state.requests = []
        app.state.state = "start" …

我目前正在用 Julia 编写一个数值求解器。我认为其背后的数学并不重要。这一切都归结为这样一个事实：特定操作会执行多次并占用很大比例（~80%）的运行时间。

我尝试尽可能地减少它并向您展示这段代码，它可以保存为dummy.jl然后通过include("dummy.jl")后跟dummy(10)（用于编译）然后执行dummy(1000)。

function dummy(N::Int64)
    A = rand(N,N)
    @time timethis(A)
end

function timethis(A::Array{Float64,2})
    dummyvariable = 0.0
    for k=1:100 # just repeat a few times
        for i=2:size(A)[1]-1
            for j=2:size(A)[2]-1
                    dummyvariable += slopefit(A[i-1,j],A[i,j],A[i+1,j],2.0)
                    dummyvariable += slopefit(A[i,j-1],A[i,j],A[i,j+1],2.0)
            end
        end
    end
    println(dummyvariable) 
end

@inline function minmod(x::Float64, y::Float64)
    return sign(x) * max(0.0, min(abs(x),y*sign(x) ) );
end

@inline function slopefit(left::Float64,center::Float64,right::Float64,theta::Float64)
    # arg=ccall((:minmod,"libminmod"),Float64,(Float64,Float64),0.5*(right-left),theta*(center-left));
    # result=ccall((:minmod,"libminmod"),Float64,(Float64,Float64),theta*(right-center),arg);
    # return result

    tmp = minmod(0.5*(right-left),theta*(center-left));
    return minmod(theta*(right-center),tmp);
    #return 1.0
end

这里，timethis …

我正在使用Julia v0.6.4.考虑以下模块,保存在FooModule.jl:

module FooModule

export Foo
export doSomething

mutable struct Foo
    x::Int64
    function Foo(xin::Int64)
        new(xin)
    end # Foo
end # struct

function doSomething(F::Foo)
    println(F.x+123)
end # doSomething

end # module

并且main.jl:

using FooModule
function main()
F = Foo(10)
doSomething(F)
end # main

现在我开始Julia REPL:

julia> include("main.jl");

julia> main()
133

即我得到了我的期望.现在想象doSomething包含许多行,我想分裂FooModule.jl.我想做这样的事情:

module FooModule

export Foo
export doSomething

include("doSomething.jl")        # <- include instead of writing out

mutable struct Foo
    x::Int64
    function Foo(xin::Int64)
        new(xin)
    end …

我已经为蒙特卡罗模拟编写了 CUDA 代码。我基本上有许多粒子并执行某些操作。为了计算我的 3D 网格的每个单元格的密度，我有一个数组（在设备上），我为每个粒子分配一个单元格 ID。这是通过 CUDA 完成的。然后我想将设备内存复制到主机以计算密度并将值写入文件。

但是，在运行我的代码时，cudaMemcpy没有响应并且语句之后的代码没有执行。我担心我在分配数组时做错了什么，如果有人能指出我的错误，我会很高兴。

这是代码的重要部分：

size_t sizeInt = dim*numParticles *sizeof(int);
...
int *h_cellIndex = NULL; // host
err = cudaHostAlloc((void **)&h_cellIndex, sizeInt,0);
//int *h_cellIndex = (int*) malloc(sizeInt);  <- this instead didn't work either
...
int *d_cellIndex = NULL; // device
err = cudaMalloc((void **)&d_cellIndex, sizeInt);
...
// simulation starts
...
printf("copy\n");
cudaMemcpy(h_cellIndex,d_cellIndex,sizeInt,cudaMemcpyDeviceToHost);
printf("copy done\n");

作为输出，我看到“复制”打印到命令行。然后什么也没有发生，没有分段错误，也没有进一步的计算。

知道可能是什么问题吗？

提前致谢！

我的Julia代码中的以下部分会杀死我的所有表现:

        for j = 1:size(phi,3)
            for i = 1:size(phi,2)
                    phi[:,i,j] += dt*convolutionmagnitude*
                                    weightMatrix*phi[:,i,j]                     
            end
        end 

即phi三张量,对于每一个i,j我们想要通过矩阵向量乘积更新第一维(乘以一些标量).weightMatrix是大小的矩阵size(phi,1)通过size(phi,1)(这可能是在未来稀疏).一切都发生了floats.

Julia分配了大量内存,即使一切都应该到位(至少我希望如此).我已阅读了julia文档并发现view但无法使用它.我怎样才能加速这个计算？