小编aar*_*gon的帖子

想象一下,你有一个简单的矩阵类

template <typename T = double>
class Matrix {

  T* data;
  size_t row, col;

public:

  Matrix(size_t m, size_t n) : row(m), col(n), data(new T[m*n]) {}
  //...       

  friend std::ostream& operator<<(std::ostream& os, const Matrix& m) {
    for (int i=0; i<m.row; ++i) {
      for (int j=0; j<m.col; ++j)
        os<<" "<<m.data[i + j*m.row];
      os<<endl;
    }
    return os;
  }
};      

有没有办法用初始化列表初始化这个矩阵？我的意思是从初始化列表中获取矩阵和元素的大小.类似下面的代码:

Matrix m = { {1., 3., 4.}, {2., 6, 2.}};

会打印

 1 3 4
 2 6 2

期待您的回答.谢谢你们.AA

编辑

所以我研究了你的建议来制作一个使用初始化列表初始化元素的通用数组.但这是我能获得的最通用的.如果你们中的任何人有任何建议可以使它成为一个更通用的课程,我将不胜感激.还有几个问题:

• 派生类初始化基类的状态是否正常？我不是因为这个而调用基础构造函数,但是我应该调用它吗？
• 我将析构函数定义为Generic_base类是受保护的,这是正确的方法吗？
• 是否有任何可预见的方法以更通用的方式执行属于初始化程序的构造函数的代码？我的意思是有一个 …

我是Python虚拟环境的新手,所以在阅读本教程之后,我尝试使用创建我的第一个环境virtualenvwrapper.我的python3安装现在是裸机:

$ pip3 list
argparse (1.2.1)
pip (1.5.6)
setuptools (2.1)
stevedore (0.15)
virtualenv (1.11.6)
virtualenv-clone (0.2.5)
virtualenvwrapper (4.3.1)

根据教程的建议,我在.bashrc文件中添加了以下行:

export WORKON_HOME=$HOME/.virtualenvs
source /Library/Frameworks/Python.framework/Versions/3.4/bin/virtualenvwrapper_lazy.sh

当我打开一个新终端时会产生以下消息:

Last login: Wed Sep 10 22:33:17 on ttys006
-bash: _VIRTUALENVWRAPPER_API: unbound variable
-bash: VIRTUALENVWRAPPER_SCRIPT: unbound variable
-bash: VIRTUALENVWRAPPER_SCRIPT: unbound variable
-bash: _VIRTUALENVWRAPPER_API: unbound variable
-bash: _VIRTUALENVWRAPPER_API: unbound variable
complete: usage: complete [-abcdefgjksuv] [-pr] [-o option] [-A action] [-G globpat] [-W wordlist] [-P prefix] [-S suffix] [-X filterpat] [-F …

假设你想要创建一个混合C++和Python的编程项目.的富 C++项目结构使用的CMake和Python的模块是通过使用创建的痛饮.树结构看起来像这样:

??? CMakeLists.txt
??? FooConfig.cmake.in
??? FooConfigVersion.cmake.in
??? Makefile
??? README
??? foo
?   ??? CMakeLists.txt
?   ??? config.hpp.in
?   ??? foo.cpp
?   ??? foo.hpp
??? swig
    ??? foo.i

现在你想在Python项目中使用Foo项目,比如Bar:

??? AUTHORS.rst
??? CONTRIBUTING.rst
??? HISTORY.rst
??? LICENSE
??? MANIFEST.in
??? Makefile
??? README.rst
??? docs
?   ??? Makefile
?   ??? authors.rst
?   ??? conf.py
?   ??? contributing.rst
?   ??? history.rst …

我正在设计有限元素库.对于给定的问题,所使用的有限元网格可以具有不同尺寸的元素(例如四面体和三角形),并且也可以组合相同尺寸的不同元素(例如四面体和六面体).因此,我需要一个存储有限元信息的数据结构.最基本的信息是元素的连接性(定义元素的节点ID).例如,我需要以某种方式存储三角形元素4连接到节点5,6和10.

我的第一次尝试是创建一个列表,其索引是维度(0,1,2或3)并存储字典.这些字典具有字符串键(标识符),值为numpy数组(每行代表元素连接).我需要这样做,因为给定维度的numpy数组具有不同的形状,具体取决于字符串标识符.

这是班级:

import os
from collections import OrderedDict
import numpy.ma as ma

flatten = lambda l: [item for sublist in l for item in sublist]

class ElementData(list):

    def __init__(self, *args, **kwargs):

        self.reset()
        super(ElementData, self).__init__(*args, **kwargs)

    def __iter__(self):
        for k, v in self[self.idx].items():
            for i, e in enumerate(v):
                yield (k,i,e) if not ma.is_masked(e) else (k,i, None)
        self.reset()


    def __call__(self, idx):
        self.idx = idx-1
        return self

    def __getitem__(self, index):
        if index >= len(self):
            self.expand(index)
        return super(ElementData, self).__getitem__(index)

    def __setitem__(self, index, value): …

在试图找到我的问题的答案一段时间后,我决定询问是否有人有同样的问题.

我有一个使用cmake构建系统的c ++项目.我使用Macbook Pro进行开发,所以当我使用终端时,一切都像魅力一样,我可以构建我的项目.

但是,今天我发现在使用cmake生成器创建相应项目后我可以使用Xcode:

$> cmake -G Xcode .

它适用于项目,它看起来很好,除了我无法构建任何东西.它无法识别包含文件中包含的符号.有谁知道这是为什么？似乎cmake环境变量没有传递给Xcode.

谁能指出我正确的方向？谢谢你们,

AA

我在Python的Enum类中发现了一个非常奇怪的行为.所以枚举类型很简单:

from enum import Enum
Analysis = Enum('Analysis', 'static dynamic')

所以我将这个枚举类型用于步骤对象,以便它们将它存储在属性分析中,如下所示:

class Step:
    def __init__(self):
        self.analysis = None
        self.bcs = []

到目前为止非常简单,所以当我在列表中有一些这些步骤时,我会尝试查看枚举类型并且已正确分配.但他们并不平等:

# loop over steps
for s, step in enumerate(kwargs['steps']):
    print(kwargs)
    print(step)
    print(step.analysis)
    print("test for equality: ",(step.analysis == Analysis.static))
    quit()

打印

{'mesh': <fem.mesh.mesh.Mesh object at 0x10614d438>,
 'steps': [<hybrida.fem.step.Step object at 0x10614d278>,
           <hybrida.fem.step.Step object at 0x10616a710>,
           <hybrida.fem.step.Step object at 0x10616a390>]}
Step:
  analysis: Analysis.static
  bcs: [<hybrida.fem.conditions.dirichlet.Dirichlet object at 0x10616a0f0>,
        <hybrida.fem.conditions.dirichlet.Dirichlet object at 0x10616a320>,
        <hybrida.fem.conditions.dirichlet.Dirichlet object at 0x10616a3c8>,
        <hybrida.fem.conditions.dirichlet.Dirichlet object at 0x10616a470>, …

我需要一个存储字典的字典数据结构,如下所示:

custom = {1: {'a': np.zeros(10), 'b': np.zeros(100)}, 
          2: {'c': np.zeros(20), 'd': np.zeros(200)}}

但问题是我在代码中多次迭代这个数据结构.每次迭代它时,我都需要遵守迭代的顺序,因为这个复杂数据结构中的所有元素都映射到一维数组(如果你愿意,可以序列化),因此顺序很重要.我考虑过编写一个有序dict的订单dict,但我不确定这是正确的解决方案,因为我似乎可能选择了错误的数据结构.对我的案子来说,最合适的解决办法是什么？

UPDATE

所以这就是我到目前为止所提出的:

class Test(list):

    def __init__(self, *args, **kwargs):

        super(Test, self).__init__(*args, **kwargs)

        for k,v in args[0].items():
            self[k] = OrderedDict(v)

        self.d = -1
        self.iterator = iter(self[-1].keys())
        self.etype = next(self.iterator)
        self.idx = 0


    def __iter__(self):
        return self

    def __next__(self):

        try:
            self.idx += 1
            return self[self.d][self.etype][self.idx-1]

        except IndexError:

            self.etype = next(self.iterator)
            self.idx = 0
            return self[self.d][self.etype][self.idx-1]

    def __call__(self, d):

        self.d = -1 - d
        self.iterator = …

来自C ++世界，我习惯于基于标志来编写条件编译，这些标志是在编译时使用CMake等工具确定的。我想知道最模仿这种功能的Python方法是什么。例如，这是我当前根据是否找到模块设置的设置：

import imp

try:
    imp.find_module('petsc4py')
    HAVE_PETSC=True
except ImportError:
    HAVE_PETSC=False

然后，我可以使用HAVE_PETSC其余的Python代码。这行得通，但是我想知道这是否是在Python中执行的正确方法。

我正在尝试获取稀疏矩阵的条件编号。到目前为止，我设法做到的方法是将矩阵转换为稠密的，然后获得其特征值：

$ python
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 26 2016, 10:47:25) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> from numpy import array
>>> import numpy as np
>>> import scipy.sparse as sparse
>>> I = array([0,3,1,0])
>>> J = array([0,3,1,2])
>>> V = array([4,5,7,9])
>>> A = sparse.coo_matrix((V,(I,J)),shape=(4,4))
>>> A = A.todense()
>>> eig = np.linalg.eig(A)
>>> eig = eig[0].real, np.array(eig[1].real)
>>> def split(array, cond):
...     return (array[cond], …

是否有可能有一个泛型构造函数,它接受任何类型的初始化列表,即使它有嵌套列表？

假设您对接受其构造函数嵌套初始化列表的类具有以下部分模板特化:

模板类ClassA;

template <>
class ClassA<4> {

  typedef std::initializer_list<double> list_type;
  typedef std::initializer_list<list_type> llist_type;
  typedef std::initializer_list<llist_type> lllist_type;
  typedef std::initializer_list<lllist_type> initializer_type;

  size_t n_[4] = {0};
  double* data_;

public:

  ClassA(initializer_type l) {

    assert(l.size() > 0);
    assert(l.begin()->size() > 0);
    assert(l.begin()->begin()->size() > 0);
    assert(l.begin()->begin()->begin()->size() > 0);

    size_t m = n_[0] = l.size();
    size_t n = n_[1] = l.begin()->size();
    size_t o = n_[2] = l.begin()->begin()->size();
    n_[3] = l.begin()->begin()->begin()->size();

    data_ = new double[m*n*o*n_[3]];

    int i=0, j=0, k=0, p=0;
    for (const auto& u : l) {
      assert(u.size() …