小编Jer*_*wen的帖子

我试图让X Window在屏幕上的某个位置.当我要求人们执行此功能时,他们说你只是递归调用XQueryTree.

这是我认为在某种程度上错误的代码片段.当我调试它时,它似乎工作得很好.唯一的问题是它给出的输出似乎有点奇怪.当我在根窗口上执行XQueryTree时,我得到了数百个孩子,当时我只有五个左右打开.此外,它似乎认为在某个地方有一个顶级窗口,根本没有一个,并返回它作为结果.无论我如何移动我的实际窗口,XQueryTree似乎都表明我的窗口顶部还有另一个窗口(不覆盖整个屏幕.)当我看到窗口所在的位置时,它处于某个任意点我的桌面.

如果这有任何帮助:显示来自XOpenDisplay(NULL),我最初传递它的根窗口是XDefaultRootWindow(显示).我在debian下使用metacity运行gnome.

point getwindowatloc(Display * display, Window root, jint x, jint y) {
        Window returnedroot;
        Window returnedparent;
        Window * children;
        unsigned int numchildren;
        XQueryTree(display,root,&returnedroot,&returnedparent,&children, &numchildren);
        XWindowAttributes w;
        int i;
        for(i=numchildren-1; i>=0; i--) {
            XGetWindowAttributes(display,children[i],&w);   
            if(x>=w.x && x<=w.x+w.width && y>=w.y && y <= w.y+w.height) {
                point result={w.x,w.y};
                XFree(children);
                return result;
            } else {
                point result=getwindowatloc(display,children[i],x-w.x,y-w.y);
                if(result.x!=INT_MAX) {
                    result.x+=w.x;
                    result.y+=w.y;
                    XFree(children);
                    return result;
                }
            }
        }
        if(children) {
            XFree(children);
        }
        return notfound;
    }

谢谢!

编辑:对于正在搜索类似信息的人:我最终查看了xwininfo的来源.关键函数是dsimple.c中的Find_Client,它以某种方式忽略了窗口管理器以获取您实际需要的窗口.如果你想查看子窗口,这是我在dsimple.c中添加到Select_Window的一些代码,它将使用XTranslateCoordinates以递归的方式查看子窗口.

Window …

我正在编写一个用于优化的C++库,我遇到了一个与变体类型有关的奇怪问题.

因此,我根据他们可以计算的信息定义"功能"的层次结构.

class Function {
 public:
    double value()=0;
}

class DifferentiableFunction : public Function {
 public:
  const double* gradient()=0;
}

class TwiceDifferentiableFunction : public DifferentiableFunction {
 public:
    const double* hessian()=0;
}

这一切都很好,但现在我想为优化器定义接口.例如,一些优化器需要梯度信息或粗体信息才能进行优化,有些则不需要.因此,优化器的类型与函数的类型相反.

class HessianOptimizer {
 public:
    set_function(TwiceDifferentiableFunction* f)=0;
}

class GradientOptimizer : public HessianOptimizer {
 public:
    set_function(DifferentiableFunction* f)=0;
}

class Optimizer: public GradientOptimizer {
 public:
    set_function(TwiceDifferentiableFunction* f)=0;
}

从类型理论的角度来看,我认为这是有道理的,但奇怪的是,通常当人们想要扩展代码时,他们将继承现有的类.因此,例如,如果其他人正在使用此库,并且他们想要创建一种需要比粗麻布更多信息的新类型的优化器,他们可能会创建类似的类

class ThriceDifferentiableFunction: public TwiceDifferentiableFunction }
 public:
    const double* thirdderivative()=0;
}

但是随后要创建相应的优化器类,我们必须使HessianOptimizer扩展ThirdOrderOptimizer.但是库用户必须修改库才能这样做!因此,虽然我们可以在不必修改库的情况下添加ThriceDifferentiableFunction,但似乎逆变类型会丢失此属性.这似乎只是类声明其父类型而非子类型的事实.

但是你应该怎么处理这个呢？有没有办法很好地做到这一点？

夜间生锈：

操场

struct Foo<T, F: Fn(&T, &T) -> T> {
    value: T,
    func: F
}

fn main() {
    let lambda = |&x, &y| x + y;
    let foo = Foo {
        value: 5 as i32,
        func: lambda
    };
}

错误信息：

struct Foo<T, F: Fn(&T, &T) -> T> {
    value: T,
    func: F
}

fn main() {
    let lambda = |&x, &y| x + y;
    let foo = Foo {
        value: 5 as i32,
        func: lambda
    };
}

请注意，预期类型和找到的类型是相同的字符。为什么错误消息说一种类型比另一种更通用，同时还说它们是同一类型？

我正在尝试在GNU/Linux上分析一个共享库来进行实时音频处理,因此性能非常重要.我运行另一个程序,它将它连接到我的系统的音频输入和输出,并使用callgrind配置它.

查看KCacheGrind中的结果,我可以获得有关哪些函数占用大部分时间的大量信息.但是,它不会让我看一行一行的信息,而是说我需要用调试符号编译它并再次运行分析.

我正在分析的程序没有使用调试符号编译,但库是.我知道这一点,因为有趣的是,cachegrind的源代码注释工作正常.

当我运行callgrind时,它说默认是转储源行信息,但它只是没有这样做.有什么方法可以强制它,或弄清楚是什么阻止它？

我有以下C程序(我的实际用例的简化,表现出相同的行为)

#include <stdlib.h>
#include <math.h>
int main(int argc, char ** argv) {
    const float * __restrict__ const input = malloc(20000*sizeof(float));
    float * __restrict__ const output = malloc(20000*sizeof(float));

    unsigned int pos=0;
    while(1) {
            unsigned int rest=100;
            for(unsigned int i=pos;i<pos+rest; i++) {
                    output[i] = input[i] * 0.1;
            }

            pos+=rest;            
            if(pos>10000) {
                    break;
            }
    }
}

当我编译时

 -O3 -g -Wall -ftree-vectorizer-verbose=5 -msse -msse2 -msse3 -march=native -mtune=native --std=c99 -fPIC -ffast-math

我得到了输出

main.c:10: note: not vectorized: unhandled data-ref 

其中10是内部for循环的行.当我查找为什么它可能会这样说时,它似乎是说指针可能是别名,但它们不能在我的代码中,因为我有__restrict关键字.他们还建议包括-msse标志,但它们似乎也没有做任何事情.有帮助吗？

使用GNU ld 2.21运行Debian/Linux x86_64.

很简单,如果我链接

ld -o main main.o /usr/lib/crti.o /usr/lib/crt1.o /usr/lib/crtn.o -lc -lm

它有效,但是当我链接时

ld -r -o main1.o main.o /usr/lib/crti.o /usr/lib/crt1.o /usr/lib/crtn.o -lc -lm

它抱怨

ld: cannot find -lc
ld: cannot find -lm

我实际上并没有尝试以这种方式编译代码,而是我试图弄清楚为什么别人的测试看看库是否存在无效.(因此我真的不明白发生了什么ld......通常我只是用GCC来链接)

为什么要ld以可重定位的方式链接使它突然无法找到库？如果我只是想测试它-lm存在,我还应该做些什么

ld -r -lm

这样它会找到图书馆吗？

如果你想查看我正在处理的源代码,可以在这里下载:https://github.com/jeremysalwen/ESPS (注意,第一次提交是原始源代码,后续的是更改我亲自做过.)

我有两个假设，我想使用正向推理来应用使用这两个假设的定理。

我的具体情况我有假设

H0 : a + b = c + d
H1 : e + f = g + h

我想应用标准库中的定理：

f_equal2_mult
     : forall x1 y1 x2 y2 : nat, x1 = y1 -> x2 = y2 -> x1 * x2 = y1 * y2

现在我知道我可以手动给出 x1, y1, x2, y2 的值​​，但我希望 Coq 在与H0和统一时自动确定这些值H1。我发现我可以让它像这样工作：

eapply f_equal2_mult in H0; try exact H1.

但这感觉就像是一种黑客攻击，对称性破缺，而且try. 我真的很希望能够说apply f_equals2_mult in H0, H1一些类似的话。有这样的办法吗？

当你执行

jeremy@home:/$DOG=happy; echo $DOG;

你得到了输出

happy

但是,当你执行jeremy @ home时:/ $ sh -c"DOG = happy; echo $ DOG;"

甚至

jeremy@home:/$sh -c "DOG=happy; echo "$DOG";"

要么

jeremy@home:/$sh -c "DOG=happy; echo \"$DOG\";"

要么

jeremy@home:/$sh -c "DOG=happy; echo '$DOG';"

你只得到一个空白行.这是怎么回事？如何从sh -c命令中实际设置变量？

我正在尝试包装一个使用这样的模式的C库:

Thing* x= new_thing_("blah");
Thing* tmp= thing_copy(x);
free_thing(tmp);
Other* y=get_other(x,7);
char* message=get_message(x,y);
free_thing(x);
free_other(y);

在c ++中,我希望能够做类似的事情

auto_ptr<CXXThing> x=new CXXThing("blah");
auto_ptr<CXXThing> tmp=new CXXThing(*x);
auto_ptr<CXXOther> y=x->get_other(7);
char* message = y->get_message();

显然,CXXOther也包含指向CXXThing的指针.所以我遇到的问题是,基本上我只想将函数和成员"插入"到现有的结构中(我认为这被称为"Mixin"的想法).

问题是,如果我将Thing作为CXXThing的一个元素包含在内,那么我不知道我是如何声明构造函数的,如果我包含一个指向包装类的指针,那么我有一个额外级别的无用间接.

我应该如何包装它以便这可能？(回答"你想做什么不是最好/可能......这里是正确的方法"也是可以接受的.)

我有两个基本相同的特征,但是一个提供了比另一个更低级别的接口.鉴于较高水平的特性,人们可以轻松实现较低水平的特质.我想写一个接受任一trait实现的库.

我的具体案例是遍历树的特征:

// "Lower level" version of the trait
pub trait RawState {
    type Cost: std::cmp::Ord + std::ops::Add<Output = Self::Cost> + std::marker::Copy;
    type CulledChildrenIterator: Iterator<Item = (Self, Self::Cost)>;
    fn cull(&self) -> Option<Self::Cost>;
    fn children_with_cull(&self) -> Self::CulledChildrenIterator;
}
// "Higher level" version of the trait
pub trait State: RawState {
    type ChildrenIterator: Iterator<Item = (Self, Self::Cost)>;
    fn children(&self) -> Self::ChildrenIterator;
}

// Example of how RawState could be implemented using State
fn state_children_with_cull<S: State> (s: S)
     -> impl Iterator<Item = (S, …

例如,如果我定义一个从nat到nat的函数,那就是

Definition plusfive(a:nat): nat := a + 5.

但是,我想定义一个函数,其参数是使用"S"构造函数(即非零)构造的nat,是否可以直接指定为类型？就像是

Definition plusfive(a: nat.S): nat := a + 5.

(我知道在这种情况下我也可以添加一个a非零的证明的参数,但我想知道是否可以根据'S'构造函数直接命名类型).

如果定义了宏kIndependentMacro,我想将宏kDependentMacro定义为38,否则为40.最简单的方法是什么？