def build_from_float_array(self, name="fromArray", separator=", "):
if self.base_ring == "float":
return ""
if not self.uniform_member_type:
raise TypeError(
"To generate an array constructor, GlslStruct must have members of\
uniform type"
)
template = Template(
"""\
$type_name $fn_name(float X[$size]){
return $type_name($array_members);
}"""
)
x = IndexedBase("X")
array_members = separator.join(["{}({})".format(self.typed_name(SCALAR, self.base_ring), str(x[i])) for i in range(len(self))])
return template.substitute(
fn_name=name,
type_name=self.type_name,
base_type=self.uniform_member_type,
array_members=array_members,
size=len(self),
)
def initSyms(syms, deferred=False):
sym_dict = {}
if not isinstance(syms, list) and not isinstance(syms, set):
syms = [syms]
for sym in syms:
sym_dict[sym] = symbols(sym) if not deferred else IndexedBase(sym)
return sym_dict
def test_canonicalization_of_vectors_w_symm(free_alg):
"""Test the canonicalization when vectors are given (anti-)symmetries.
"""
dr = free_alg
p = dr.names
x = IndexedBase('x')
r = p.R
i, j = p.i, p.j
vs = Vec('vs')
dr.set_symm(vs, Perm([1, 0]), valence=2)
tensor = dr.sum((i, r), (j, r), x[i, j] * vs[j, i])
res = tensor.simplify()
assert res.n_terms == 1
term = res.local_terms[0]
assert term.sums == ((i, r), (j, r))
assert term.amp == x[i, j]
assert term.vecs == (vs[i, j], )
va = Vec('va')
dr.set_symm(va, Perm([1, 0], NEG), valence=2)
tensor = dr.sum((i, r), (j, r), x[i, j] * va[j, i])
res = tensor.simplify()
assert res.n_terms == 1
term = res.local_terms[0]
assert term.sums == ((i, r), (j, r))
assert term.amp == -x[i, j]
assert term.vecs == (va[i, j], )
def test_IndexedBase_assumptions():
i = Symbol('i', integer=True)
a = Symbol('a')
A = IndexedBase(a, positive=True)
for c in (A, A[i]):
assert c.is_real
assert c.is_complex
assert not c.is_imaginary
assert c.is_nonnegative
assert c.is_nonzero
assert c.is_commutative
assert log(exp(c)) == c
assert A != IndexedBase(a)
assert A == IndexedBase(a, positive=True, real=True)
assert A[i] != Indexed(a, i)
def test_sum_instantiator():
"""Test use of Sum instantiator."""
i = IdxSym('i')
j = IdxSym('j')
ket_i = BasisKet(FockIndex(i), hs=0)
ket_j = BasisKet(FockIndex(j), hs=0)
A_i = OperatorSymbol(StrLabel(IndexedBase('A')[i]), hs=0)
hs0 = LocalSpace('0')
sum = Sum(i)(ket_i)
ful = KetIndexedSum(ket_i, ranges=IndexOverFockSpace(i, hs=hs0))
assert sum == ful
assert sum == Sum(i, hs0)(ket_i)
assert sum == Sum(i, hs=hs0)(ket_i)
sum = Sum(i, 1, 10)(ket_i)
ful = KetIndexedSum(ket_i, ranges=IndexOverRange(i, 1, 10))
assert sum == ful
assert sum == Sum(i, 1, 10, 1)(ket_i)
assert sum == Sum(i, 1, to=10, step=1)(ket_i)
assert sum == Sum(i, 1, 10, step=1)(ket_i)
sum = Sum(i, (1, 2, 3))(ket_i)
ful = KetIndexedSum(ket_i, ranges=IndexOverList(i, (1, 2, 3)))
assert sum == KetIndexedSum(ket_i, ranges=IndexOverList(i, (1, 2, 3)))
assert sum == Sum(i, [1, 2, 3])(ket_i)
sum = Sum(i)(Sum(j)(ket_i * ket_j.dag()))
ful = OperatorIndexedSum(
ket_i * ket_j.dag(),
ranges=(IndexOverFockSpace(i, hs0), IndexOverFockSpace(j, hs0)),
)
assert sum == ful
def indexed_symbol(symbol, shape, idx_symbols):
base = IndexedBase(symbol,
shape=tuple(s for s in shape if s > 1),
strides='C')
index = tuple(idx_sym for idx, idx_sym in enumerate(idx_symbols)
if shape[idx] > 1)
return IndexedEx(base, *index)
def test_MultivariateEwens():
from sympy.stats.joint_rv_types import MultivariateEwens
n, theta, i = symbols('n theta i', positive=True)
# tests for integer dimensions
theta_f = symbols('t_f', negative=True)
a = symbols('a_1:4', positive=True, integer=True)
ed = MultivariateEwens('E', 3, theta)
assert density(ed)(a[0], a[1], a[2]) == Piecewise(
(6 * 2**(-a[1]) * 3**(-a[2]) * theta**a[0] * theta**a[1] *
theta**a[2] /
(theta * (theta + 1) *
(theta + 2) * factorial(a[0]) * factorial(a[1]) * factorial(a[2])),
Eq(a[0] + 2 * a[1] + 3 * a[2], 3)), (0, True))
assert marginal_distribution(ed, ed[1])(a[1]) == Piecewise(
(6 * 2**(-a[1]) * theta**a[1] /
((theta + 1) * (theta + 2) * factorial(a[1])), Eq(2 * a[1] + 1, 3)),
(0, True))
raises(ValueError, lambda: MultivariateEwens('e1', 5, theta_f))
# tests for symbolic dimensions
eds = MultivariateEwens('E', n, theta)
a = IndexedBase('a')
j, k = symbols('j, k')
den = Piecewise((factorial(n) *
Product(theta**a[j] * (j + 1)**(-a[j]) / factorial(a[j]),
(j, 0, n - 1)) / RisingFactorial(theta, n),
Eq(n, Sum((k + 1) * a[k], (k, 0, n - 1)))), (0, True))
assert density(eds)(a).dummy_eq(den)
def __init__(self, polynomials, variables):
"""
A class that takes two lists, a list of polynomials and list of
variables. Returns the Dixon matrix of the multivariate system.
Parameters
----------
polynomials : list of polynomials
A list of m n-degree polynomials
variables: list
A list of all n variables
"""
self.polynomials = polynomials
self.variables = variables
self.n = len(self.variables)
self.m = len(self.polynomials)
a = IndexedBase("alpha")
# A list of n alpha variables (the replacing variables)
self.dummy_variables = [a[i] for i in range(self.n)]
# A list of the d_max of each variable.
self.max_degrees = [
max(degree_list(poly)[i] for poly in self.polynomials)
for i in range(self.n)
]
def partial_derivative_as_symbol(expr, name=None, dim=None):
"""Returns a Symbol from a partial derivative expression."""
if not isinstance(expr, _partial_derivatives):
raise TypeError('Expecting a partial derivative expression')
index = get_index_derivatives(expr)
var = get_atom_derivatives(expr)
if not isinstance(var, (Symbol, Indexed)):
print(type(var))
raise TypeError('Expecting a Symbol, Indexed')
code = ''
for k, n in list(index.items()):
code += k * n
if var.is_Indexed:
if name is None:
name = var.base
indices = ''.join('{}'.format(i) for i in var.indices)
name = '{name}_{code}'.format(name=name, code=code)
shape = None
if dim:
shape = [dim]
return IndexedBase(name, shape=shape)[indices]
else:
if name is None:
name = var.name
name = '{name}_{code}'.format(name=name, code=code)
return Symbol(name)
def g(v,w,i):
from sympy import Lambda, Function ,symbols ,IndexedBase,Idx ,Max, Sum
x = Function('x')
i, n, j, dim, k =symbols('i, n, j, dim, k')
v=IndexedBase('v')
w=IndexedBase('w')
net = Lambda((i, n, dim, k), Max(0.0, Sum(x(k)*w[n, k, i], (k, 0, dim-1))))
dim = [10**4]*10
index =[symbols('i%s'%m) for m in range(len(dim)+1)]
y = [0]*len(dim)
new = v[index[0]]
for n in range(len(dim)):
y[n] = net(index[n+1], n, dim[n], index[n])
y[n] = y[n].subs(x(index[n]), new)
new = y[n]
return y[-1]
def test_Assignment():
x, y = symbols("x, y")
A = MatrixSymbol('A', 3, 1)
mat = Matrix([1, 2, 3])
B = IndexedBase('B')
n = symbols("n", integer=True)
i = Idx("i", n)
# Here we just do things to show they don't error
Assignment(x, y)
Assignment(x, 0)
Assignment(A, mat)
Assignment(A[1, 0], 0)
Assignment(A[1, 0], x)
Assignment(B[i], x)
Assignment(B[i], 0)
a = Assignment(x, y)
assert a.func(*a.args) == a
# Here we test things to show that they error
# Matrix to scalar
raises(ValueError, lambda: Assignment(B[i], A))
raises(ValueError, lambda: Assignment(B[i], mat))
raises(ValueError, lambda: Assignment(x, mat))
raises(ValueError, lambda: Assignment(x, A))
raises(ValueError, lambda: Assignment(A[1, 0], mat))
# Scalar to matrix
raises(ValueError, lambda: Assignment(A, x))
raises(ValueError, lambda: Assignment(A, 0))
# Non-atomic lhs
raises(TypeError, lambda: Assignment(mat, A))
raises(TypeError, lambda: Assignment(0, x))
raises(TypeError, lambda: Assignment(x * x, 1))
raises(TypeError, lambda: Assignment(A + A, mat))
raises(TypeError, lambda: Assignment(B, 0))
assert Relational(x, y, ':=') == Assignment(x, y)
def test_qubit_state_bra():
"""Test sum_i alpha_i <i| for TLS"""
i = IdxSym('i')
alpha = IndexedBase('alpha')
alpha_i = alpha[i]
hs_tls = LocalSpace('tls', basis=('g', 'e'))
term = alpha_i * BasisKet(FockIndex(i), hs=hs_tls).dag()
expr = KetIndexedSum.create(term, ranges=IndexOverFockSpace(i, hs=hs_tls))
assert IndexOverFockSpace(i, hs=hs_tls) in expr.ket.kwargs['ranges']
assert ascii(expr) == "Sum_{i in H_tls} alpha_i * <i|^(tls)"
assert expr.ket.term.free_symbols == set([i, symbols('alpha'), alpha_i])
assert expr.free_symbols == set([symbols('alpha'), alpha_i])
assert expr.ket.variables == [i]
assert expr.space == hs_tls
assert len(expr.ket.args) == 1
assert len(expr.ket.operands) == 1
assert len(expr.ket.kwargs) == 1
assert expr.ket.args[0] == term.ket
assert expr.ket.term == term.ket
assert len(expr.kwargs) == 0
expr_expand = Bra.create(expr.ket.doit().substitute({
alpha[0]: alpha['g'],
alpha[1]: alpha['e']
}))
assert expr_expand == (alpha['g'] * BasisKet('g', hs=hs_tls).dag() +
alpha['e'] * BasisKet('e', hs=hs_tls).dag())
assert ascii(expr_expand) == 'alpha_e * <e|^(tls) + alpha_g * <g|^(tls)'
def __deltaMContent(expr,
D,
gamma=IndexedBase('\gamma', integer=True, shape=1)):
"""
Compute delta M^gamma contribution for the given compartment content expr.
:param Expr expr: the content of the compartment, comprising Contents, ContentChanges, sums of those, and multiplication by integers
:param int D: the number of species
:param Expr gamma: optional symbol to use for gamma
:return:
"""
if expr.func == Compartment:
content = expr.args[0]
species = __getContentPerSpecies(content, D)
return __mpow(species, gamma)
elif expr == EmptySet:
return 0
elif expr.func == Integer:
return expr
elif expr.func == Add:
return Add(*[__deltaMContent(i) for i in expr.args])
elif expr.func == Mul:
return Mul(*[__deltaMContent(i) for i in expr.args])
else:
raise TypeError("Unexpected expression " + str(expr))
def test_Subs_with_Indexed():
A = IndexedBase("A")
i, j, k = symbols("i,j,k")
x, y, z = symbols("x,y,z")
f = Function("f")
assert Subs(A[i], A[i], A[j]).diff(A[j]) == 1
assert Subs(A[i], A[i], x).diff(A[i]) == 0
assert Subs(A[i], A[i], x).diff(A[j]) == 0
assert Subs(A[i], A[i], x).diff(x) == 1
assert Subs(A[i], A[i], x).diff(y) == 0
assert Subs(A[i], A[i], A[j]).diff(A[k]) == KroneckerDelta(j, k)
assert Subs(x, x, A[i]).diff(A[j]) == KroneckerDelta(i, j)
assert Subs(f(A[i]), A[i], x).diff(A[j]) == 0
assert Subs(f(A[i]), A[i], A[k]).diff(A[j]) == Derivative(f(A[k]), A[k])*KroneckerDelta(j, k)
assert Subs(x, x, A[i]**2).diff(A[j]) == 2*KroneckerDelta(i, j)*A[i]
assert Subs(A[i], A[i], A[j]**2).diff(A[k]) == 2*KroneckerDelta(j, k)*A[j]
assert Subs(A[i]*x, x, A[i]).diff(A[i]) == 2*A[i]
assert Subs(A[i]*x, x, A[i]).diff(A[j]) == 2*A[i]*KroneckerDelta(i, j)
assert Subs(A[i]*x, x, A[j]).diff(A[i]) == A[j] + A[i]*KroneckerDelta(i, j)
assert Subs(A[i]*x, x, A[j]).diff(A[j]) == A[i] + A[j]*KroneckerDelta(i, j)
assert Subs(A[i]*x, x, A[i]).diff(A[k]) == 2*A[i]*KroneckerDelta(i, k)
assert Subs(A[i]*x, x, A[j]).diff(A[k]) == KroneckerDelta(i, k)*A[j] + KroneckerDelta(j, k)*A[i]
assert Subs(A[i]*x, A[i], x).diff(A[i]) == 0
assert Subs(A[i]*x, A[i], x).diff(A[j]) == 0
assert Subs(A[i]*x, A[j], x).diff(A[i]) == x
assert Subs(A[i]*x, A[j], x).diff(A[j]) == x*KroneckerDelta(i, j)
assert Subs(A[i]*x, A[i], x).diff(A[k]) == 0
assert Subs(A[i]*x, A[j], x).diff(A[k]) == x*KroneckerDelta(i, k)
def __add__(self, value):
if isinstance(value, block):
temp_tape = IndexedBase('temp_tape')
new_computations = {}
subs0 = [(tape_index, self.shift), (read_index, self.reads)]
subs = []
for index, compute in self.computations.items():
compute = compute.subs(tape, temp_tape)
if isinstance(compute, assign):
subs.append((index, compute.expr))
else:
subs.append((index, compute.expr + index))
for index, compute in value.computations.items():
new_compute = compute.subs(subs0).subs(subs).subs(
temp_tape, tape)
new_computations[index.subs(subs0)] = new_compute
for index, compute in self.computations.items():
if index not in new_computations:
new_computations[index] = compute
else:
new_computations[index] = compute + new_computations[
index] #adding not communitive
new_shift = self.shift + value.shift - tape_index
new_reads = self.reads + value.reads - read_index
new_writes = self.writes + tuple(
w.subs(subs0).subs(subs).subs(temp_tape, tape)
for w in value.writes)
return block(new_computations, new_shift, new_reads, new_writes)
return NotImplemented
def test_Indexed_constructor():
i, j = symbols('i j', integer=True)
A = Indexed('A', i, j)
assert A == Indexed(Symbol('A'), i, j)
assert A == Indexed(IndexedBase('A'), i, j)
raises(TypeError, lambda: Indexed(A, i, j))
raises(IndexException, lambda: Indexed("A"))
def test_indexed_idx_sum():
i = symbols('i', cls=Idx)
r = Indexed('r', i)
assert Sum(r,
(i, 0, 3)).doit() == sum([r.xreplace({i: j}) for j in range(4)])
assert Product(r, (i, 0, 3)).doit() == prod(
[r.xreplace({i: j}) for j in range(4)])
j = symbols('j', integer=True)
assert Sum(r, (i, j, j + 2)).doit() == sum(
[r.xreplace({i: Idx(j + k)}) for k in range(3)])
assert Product(r, (i, j, j + 2)).doit() == prod(
[r.xreplace({i: Idx(j + k)}) for k in range(3)])
k = Idx('k', range=(1, 3))
A = IndexedBase('A')
assert Sum(A[k], k).doit() == sum([A[Idx(j, (1, 3))] for j in range(1, 4)])
assert Product(A[k],
k).doit() == prod([A[Idx(j, (1, 3))] for j in range(1, 4)])
raises(ValueError, lambda: Sum(A[k], (k, 1, 4)))
raises(ValueError, lambda: Sum(A[k], (k, 0, 3)))
raises(ValueError, lambda: Sum(A[k], (k, 2, oo)))
raises(ValueError, lambda: Product(A[k], (k, 1, 4)))
raises(ValueError, lambda: Product(A[k], (k, 0, 3)))
raises(ValueError, lambda: Product(A[k], (k, 2, oo)))
def get_vev(self,h_tsr: Tensor):
"""Function to evaluate the expectation value of a normal
ordered tensor 'h_tsr' with respect to the projected BCS
ground state
h_tsr = tensor whose VEV is to be evaluated
Ntot = total number of orbitals available
Note that here we follow the notation that Np = Number of Fermions and not number of pairs
"""
ctan = self.cartan
gam = IndexedBase(r'\gamma')
def vev_of_term(term):
"""Return the VEV of a given term"""
vecs = term.vecs
t_amp = term.amp
ind_list = []
if len(vecs) == 0:
return term
elif all( v.base==ctan for v in vecs ):
for i in vecs:
if set(i.indices).issubset(set(ind_list)):
t_amp = t_amp*2
# NOTE: This is only true when evaluating expectation over AGP,
# or any other seniority zero state
else:
ind_list.extend(list(i.indices))
else:
return []
t_amp = t_amp*gam[ind_list]
return [Term(sums=term.sums, amp = t_amp, vecs=())]
return h_tsr.bind(vev_of_term)
def test_evaluate_symbolic_labels():
"""Test the behavior of the `substitute` method for evaluation of symbolic
labels"""
i, j = symbols('i j', cls=IdxSym)
A = IndexedBase('A')
lbl = FockIndex(i + j)
assert lbl.substitute({i: 1, j: 2}) == 3
assert lbl.substitute({i: 1}) == FockIndex(1 + j)
assert lbl.substitute({j: 2}) == FockIndex(i + 2)
assert lbl.substitute({i: 1}).substitute({j: 2}) == 3
assert lbl.substitute({}) == lbl
lbl = StrLabel(A[i, j])
assert lbl.substitute({i: 1, j: 2}) == 'A_12'
assert lbl.substitute({i: 1}) == StrLabel(A[1, j])
assert lbl.substitute({j: 2}) == StrLabel(A[i, 2])
assert lbl.substitute({i: 1}).substitute({j: 2}) == 'A_12'
assert lbl.substitute({}) == lbl
hs = SpinSpace('s', spin=3)
lbl = SpinIndex(i + j, hs)
assert lbl.substitute({i: 1, j: 2}) == '+3'
assert lbl.substitute({i: 1}) == SpinIndex(1 + j, hs)
assert lbl.substitute({j: 2}) == SpinIndex(i + 2, hs)
assert lbl.substitute({i: 1}).substitute({j: 2}) == '+3'
assert lbl.substitute({}) == lbl
hs = SpinSpace('s', spin='3/2')
lbl = SpinIndex((i + j) / 2, hs=hs)
assert lbl.substitute({i: 1, j: 2}) == '+3/2'
assert lbl.substitute({i: 1}) == SpinIndex((1 + j) / 2, hs)
assert lbl.substitute({j: 2}) == SpinIndex((i + 2) / 2, hs)
assert lbl.substitute({i: 1}).substitute({j: 2}) == '+3/2'
assert lbl.substitute({}) == lbl
def test_tensors_can_be_substituted_scalars_simultaneously(
free_alg, full_balance):
"""Test scalar substitution facility for tensors."""
dr = free_alg
p = dr.names
x = IndexedBase('x')
r = p.R
i, j = p.R_dumms[:2]
x_def = dr.define(x[i], dr.sum(2 * x[i]))
summand = x[i]**2 * x[j]
orig = dr.sum((i, r), summand)
# k is free.
expected = dr.sum((i, r), summand * 2**3)
# Test different ways to perform the substitution.
for res in [
orig.subst(x[i], x_def.rhs, full_balance=full_balance),
orig.subst_all([x_def], full_balance=full_balance),
orig.subst_all([(x[i], x_def.rhs)], full_balance=full_balance),
x_def.act(orig, full_balance=full_balance)
]:
assert res.simplify() == expected.simplify()
def create_restrictions(self, block_endea=0x5fc):
self.C = []
self.SP_C = {}
strlen = Function('strlen')
mem = IndexedBase('mem')
memlen = Function('memlen')
cond = True
cur_block = self.dcodeblocks.get(block_endea)
var_SP_id = 0
printf(cur_block)
while cur_block is not None:
for cmd in reversed(cur_block):
if cmd.name == 'BL':
function_name = get_func_name(cmd.operands[0].value)
printf(function_name)
if function_name == '.strcpy':
self.C.append(
strlen(arm.X1) < Symbol('STACK_%d' % var_SP_id))
self.SP_C['STACK_%d' % var_SP_id] = arm.X0
var_SP_id += 1
elif function_name == 'bad_code':
printf('bad')
self.C.append(strlen(arm.X1) < 12)
self.C.append(Eq(arm.W0, 12))
elif cmd.name == 'MOV':
op0 = cmd.operands[0].value
op1 = cmd.operands[1].value
self.subs_restriction(op0, op1)
elif cmd.name == 'LDR' or cmd.name == 'LDUR':
op0 = cmd.operands[0].value
op1 = cmd.operands[1].value
self.subs_restriction(op0, mem[op1])
elif cmd.name == 'STR' or cmd.name == 'STUR':
op0 = cmd.operands[0].value
op1 = cmd.operands[1].value
self.subs_restriction(mem[op1], op0)
elif cmd.name == 'B.NE':
if cond:
self.C.append(Ne(Symbol('B.NE.0'), Symbol('B.NE.1')))
else:
self.C.append(Eq(Symbol('B.NE.0'), Symbol('B.NE.1')))
elif cmd.name == 'CMP':
op0 = cmd.operands[0].value
op1 = cmd.operands[1].value
self.subs_restriction({'B.NE.0': op0, 'B.NE.1': op1})
elif cmd.name == 'ADD':
op0 = cmd.operands[0].value
op1 = cmd.operands[1].value
op2 = cmd.operands[2].value
self.subs_restriction(op0, op1 + op2)
elif cmd.name == 'SUB':
op0 = cmd.operands[0].value
op1 = cmd.operands[1].value
op2 = cmd.operands[2].value
self.subs_restriction(op0, op1 - op2)
cond, block_endea = cur_block.refs_to_it[0]
cur_block = self.dcodeblocks.get(block_endea)
self.simplify_restriction()
return self.C, self.SP_C
def setFields(self, fields):
if len(fields) != self.rank:
print(
f"Error : please provide this function with exactly {self.rank} fields."
)
return
self.symbs = [IndexedBase(el) for el in fields]
def test_einstein_summation(genmb):
"""Test Einstein summation convention."""
dr = genmb
p = dr.names
l = p.L
a, b, c = p.L_dumms[:3]
o = IndexedBase('o')
v = IndexedBase('v')
c_dag = p.c_dag
summand = o[a, b] * v[b] * c_dag[a]
tensor = dr.einst(summand)
assert tensor == dr.sum((a, l), (b, l), summand)
summand = conjugate(o[b, a]) * v[b] * c_dag[a]
tensor = dr.einst(summand)
assert tensor == dr.sum((a, l), (b, l), summand)
def test_Indexed_coeff():
N = Symbol("N", integer=True)
len_y = N
i = Idx("i", len_y - 1)
y = IndexedBase("y", shape=(len_y,))
a = (1 / y[i + 1] * y[i]).coeff(y[i])
b = (y[i] / y[i + 1]).coeff(y[i])
assert a == b
def test_Indexed_constructor():
i, j = symbols("i j", integer=True)
A = Indexed("A", i, j)
assert A == Indexed(Symbol("A"), i, j)
assert A == Indexed(IndexedBase("A"), i, j)
raises(TypeError, lambda: Indexed(A, i, j))
raises(IndexException, lambda: Indexed("A"))
assert A.free_symbols == {A, A.base.label, i, j}
def test_Indexed_coeff():
N = Symbol('N', integer=True)
len_y = N
i = Idx('i', len_y - 1)
y = IndexedBase('y', shape=(len_y, ))
a = (1 / y[i + 1] * y[i]).coeff(y[i])
b = (y[i] / y[i + 1]).coeff(y[i])
assert a == b
def test_3d_block_1():
print('============== test_3d_block_1 ================')
x, y, z = symbols('x y z')
u = IndexedBase('u')
v = IndexedBase('v')
a = Lambda((x, y, z, v, u), Dot(Curl(u), Curl(v)) + 0.2 * Dot(u, v))
# ... create a finite element space
p1 = 2
p2 = 2
p3 = 2
ne1 = 2
ne2 = 2
ne3 = 2
print('> Grid :: [{},{},{}]'.format(ne1, ne2, ne3))
print('> Degree :: [{},{},{}]'.format(p1, p2, p3))
grid_1 = linspace(0., 1., ne1 + 1)
grid_2 = linspace(0., 1., ne2 + 1)
grid_3 = linspace(0., 1., ne3 + 1)
V1 = SplineSpace(p1, grid=grid_1)
V2 = SplineSpace(p2, grid=grid_2)
V3 = SplineSpace(p3, grid=grid_3)
W = TensorFemSpace(V1, V2, V3)
# ...
# ... vector space
V = VectorFemSpace(W, W, W)
# ...
# ...
kernel_py = compile_kernel('kernel_block_1', a, V, backend='python')
kernel_f90 = compile_kernel('kernel_block_1', a, V, backend='fortran')
M_py = assemble_matrix(V, kernel_py)
M_f90 = assemble_matrix(V, kernel_f90)
# ...
assert_identical_coo(M_py, M_f90)
def test_indexed_is_constant():
A = IndexedBase("A")
i, j, k = symbols("i,j,k")
assert not A[i].is_constant()
assert A[i].is_constant(j)
assert not A[1 + 2 * i, k].is_constant()
assert not A[1 + 2 * i, k].is_constant(i)
assert A[1 + 2 * i, k].is_constant(j)
assert not A[1 + 2 * i, k].is_constant(k)
def test_Indexed():
# Issue #10934
if not numpy:
skip("numpy not installed")
a = IndexedBase('a')
i, j = symbols('i j')
b = numpy.array([[1, 2], [3, 4]])
assert lambdify(a, Sum(a[x, y], (x, 0, 1), (y, 0, 1)))(b) == 10
def IndexedBases(s):
"""
declare multiple IndexedBase objects
:param s: string of names seperated by white space
returns IndxedBase objects as tuple
"""
l = s.split()
bases = [IndexedBase(x) for x in l]
return tuple(bases)
