我想使用OpenGL或Xlib在窗口上渲染字体和线条,但我想知道哪一个是"更基础".

使用Xlib接口,我可以用这样的东西(我在这里找到)来渲染这样的东西:

// gcc x_1.c -o x_1 -lX11 && ./x_1

#include <stdio.h>
#include <X11/Xlib.h>

// This program draws a red line and some text in a chosen font.
Display *display;
Window  window;
XSetWindowAttributes attributes;
XGCValues gr_values;
XFontStruct *fontinfo;
GC gr_context;
Visual *visual;
int depth;
int screen;
XEvent event;
XColor    color, dummy;

int main() {
     display = XOpenDisplay(NULL);
     screen = DefaultScreen(display);
     visual = DefaultVisual(display,screen);
     depth  = DefaultDepth(display,screen);
     attributes.background_pixel = XWhitePixel(display,screen);

     window = XCreateWindow( display,XRootWindow(display,screen),
                            200, …

我正在尝试在 CSS 中复制以下渐变：

我能做到的最好的事情是：

background:
  radial-gradient(ellipse at 20% 20%, #35234b 0%, transparent 70%),
  radial-gradient(ellipse at 60% 20%, #2975bf 0%, transparent 70%),
  radial-gradient(ellipse at 100% 20%, #3d54b1 0%, transparent 70%),
  radial-gradient(ellipse at 100% 100%, #9f3c54 0%, transparent 70%),
  radial-gradient(ellipse at 20% 100%, #362d6f 0%, transparent 70%);
background-blend-mode:screen;

这不是那么接近：

是否有可能更接近图像中的渐变？（不一定是 CSS，Javascript 也有效，甚至是外部库。但首选纯 CSS。）

background:
  radial-gradient(ellipse at 20% 20%, #35234b 0%, transparent 70%),
  radial-gradient(ellipse at 60% 20%, #2975bf 0%, transparent 70%),
  radial-gradient(ellipse at 100% 20%, #3d54b1 0%, transparent 70%),
  radial-gradient(ellipse at 100% 100%, …

1. 如何"注册"我的库foo.c,编译到libfoo.so,链接它-lfoo？是通过追加它的路径LD_LIBRARY_PATH？是跑步sudo ldconfig吗？

2. 为了好奇,我该把它"注册"给谁？也就是说,哪个应用程序"需要知道"是什么-lfoo意思才能gcc bar.c -lfoo工作？这是bash环境吗？是gcc吗？是内核吗？

3. 静态库(例如libfoo.a)是否有任何不同之处？

我正在尝试计算大量uint64的位奇偶校验.比特奇偶校验是指接受uint64的函数,如果设置的比特数是偶数则输出0,否则为1.

目前我正在使用以下功能(@Troyseph,在这里找到):

uint parity64(uint64 n){
  n ^= n >> 1;
  n ^= n >> 2;
  n = (n & 0x1111111111111111) * 0x1111111111111111;
  return (n >> 60) & 1;
}

相同的SO页面具有以下汇编例程(由@papadp提供):

.code

; bool CheckParity(size_t Result)
    CheckParity PROC
    mov     rax, 0
    add     rcx, 0
    jnp     jmp_over
    mov     rax, 1
jmp_over:
    ret
CheckParity ENDP

END

它利用了机器的奇偶校验标志.但我不能让它与我的C程序一起工作(我知道旁边没有汇编).

问题.如何在C源文件中包含上面(或类似)代码作为内联汇编,以便该parity64()函数运行该代码？

(我在Intel Xeon Haswell上使用GCC和64位Ubuntu 14)

如果它有任何帮助,则parity64()在以下例程中调用该函数:

uint bindot(uint64* a, uint64* b, uint64 entries){
    uint parity …

一个阵列是特别不一个指针.可以肯定的是,两个左值似乎都包含(1维)虚拟内存中某个位置的(1维)坐标.但请考虑这个例子.

#include <stdlib.h>
#include <stdio.h>
int main(){
  char buffer0[4096];
  char* buffer1 = malloc(4096);
  printf("lvalue %16p  sizeof %lu\n", (void *) buffer0, sizeof(buffer0));
  printf("lvalue %16p  sizeof %lu\n", (void *) buffer1, sizeof(buffer1));
// Example output:  lvalue   0x7ffcb70e8620  sizeof 4096
// Example output:  lvalue         0x7a4420  sizeof 8
}

想到的实际差异是:

1. 数组知道它们有多大(以字节为单位)(并且,通过扩展,它们知道它们有多少元素); 指针不会(但malloc() 必须知道指针有多大,知道free()只给指针多少......!)
2. 数组是"垃圾收集"(不需要free()它们); 指针必须手动释放(如果它们拥有非常重要的内存量,即通过malloc())
3. 阵列"活"在堆栈中(高虚拟内存地址,至少在我的平台上); 指针在堆中"活"(低虚拟内存地址)
4. 传递给函数时,数组会衰减为指针
5. 数组无法调整大小; 指针可以

总的来说,数组似乎比指针更聪明(但功能更少)(他们知道它们有多大,它们有多少元素,并且它们具有自动内存管理).

问题

1. 数组如何"知道"它们有多大？这是如何实现的？
2. 一般来说,如何用C语言实现数组？(编译器是这样做的,还是内核？

说有两个2D阵列，a并b

import numpy as np
a = np.random.rand(3, 4)
b = np.random.zeros(8, 8)

并且b总是大于a两个轴上的。

（编辑：b初始化为零数组，以反映所有未被其占用的元素a都将保持零的事实。）

问题。什么是最快或最Python化到“插入”的方式a进入b？

到目前为止，我已经尝试了2件事：

1. 使用np.pad于“转” a入形状的阵列(8, 8)
2. 循环遍历每行a并将其放置在其中的相应行中b

我没有尝试过使用双重嵌套循环来遍历的每个元素a，因为我认为这样做对性能不友好。

动机。每个数组a都是一个很小的字符，我想将每个字符馈入一个神经网络，该神经网络接受shape的扁平数组(8, 8)。形状数组(64,)。（我想我不能简单地展平a到一个维度并用零填充它，因为它的二维结构会变形，所以，我必须先将其“重塑”为(8, 8)，对吗？）有数百万个字符。

我正在尝试实现一个代表(几何)圆的类的最简单的例子,并且可以打印自己的数据.

Circle是一个有两个变量的类,self.radius和self.area.唯一的要求是,当更改一个变量时,另一个变量也会发生变化.

最简单的方法是什么？是property装饰品吗？

这是我的尝试.

import math


class Circle:

    def __init__(self, radius=1):
        self._radius = radius
        self._area = math.pi * radius**2

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, radius):
        self._radius = radius
        self._area = math.pi * radius**2

    @property
    def area(self):
        return self._area

    @area.setter
    def area(self, area):
        self._area = area
        self._radius = math.sqrt(area / math.pi)

    def __repr__(self):
        return 'radius {:.2f}  area {:.2f}'.format(self._radius, self._area)


c = Circle()
print(c)

c.radius = 110
print(c)

c.area = 3
print(c) …

我正在尝试编写自己的"键盘驱动程序"(没有实际编写内核模块),通过抓取键盘,我认为是用户空间中最低级别的抽象:/dev/input/event*.

下面的代码执行霎那,只要你改变的第一ocurrence ioctl(fd, EVIOCGRAB, UNGRAB) 来ioctl(fd, EVIOCGRAB, GRAB).

// gcc main.c -o main

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <linux/input.h>
#include <fcntl.h>
#include <errno.h>

#define EXIT_KEY  KEY_ESC
#define UNGRAB    0
#define GRAB      1

const char* kbd_device = "/dev/input/event4";

// ------------------------------------------------------------------------------------------------
int main(void){
  int fd = open(kbd_device, O_RDONLY);
  if(fd == -1){
    printf("Cannot open %s. %s.\n", kbd_device, strerror(errno));
    return -1;
  }

  if(ioctl(fd, EVIOCGRAB, UNGRAB))
    printf("Couldn't grab %s. %s.\n", kbd_device, strerror(errno));
  else
    printf("Grabbed %s!\n", kbd_device);

  while(1){
    struct input_event …

N线程是否可以k在x-bit 元素的数组中M x（N最多M）对-bit 元素的长度不重叠的间隔进行“原子”无锁写入？

例如。假设N是10，M是10，k是 1 并且x是8。

然后我们有10线程，一个10字节数组，每个线程将1字节写入数组。（每个线程写入不同的字节，因为根据假设，间隔是不重叠的。）

这是一个测试这是否可能的程序，或者一个线程是否“踩到邻居的脚趾”。

/*
t gcc-8  bytes1.c -o bytes1  -lpthread  &&  t ./bytes1
*/
#include <stdint.h>
typedef  uint8_t   u8;
typedef  int32_t  i32;
typedef  int64_t  i64;

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

// ----------------------------------------------------------------------------------------------------------------------------#
/* @blk1  test if multiple threads …