def test_ibin():
assert ibin(3) == [1, 1]
assert ibin(3, 3) == [0, 1, 1]
assert ibin(3, str=True) == '11'
assert ibin(3, 3, str=True) == '011'
assert list(ibin(2, 'all')) == [(0, 0), (0, 1), (1, 0), (1, 1)]
assert list(ibin(2, '', str=True)) == ['00', '01', '10', '11']
raises(ValueError, lambda: ibin(-.5))
raises(ValueError, lambda: ibin(2, 1))
def _number_theoretic_transform(seq, p, inverse=False):
"""Utility function for the Number Theoretic transform (NTT)"""
if not iterable(seq):
raise TypeError("Expected a sequence of integer coefficients " +
"for Number Theoretic Transform")
p = as_int(p)
if isprime(p) == False:
raise ValueError("Expected prime modulus for " +
"Number Theoretic Transform")
a = [as_int(x) for x in seq]
n = len(a)
if n < 1:
return a
b = n.bit_length() - 1
if n & (n - 1):
b += 1
n = 2**b
if (p - 1) % n:
raise ValueError("Expected prime modulus of the form (m*2**k + 1)")
a += [0] * (n - len(a))
for i in range(1, n):
j = int(ibin(i, b, str=True)[::-1], 2)
if i < j:
a[i], a[j] = a[j] % p, a[i] % p
pr = primitive_root(p)
rt = pow(pr, (p - 1) // n, p)
if inverse:
rt = pow(rt, p - 2, p)
w = [1] * (n // 2)
for i in range(1, n // 2):
w[i] = w[i - 1] * rt % p
h = 2
while h <= n:
hf, ut = h // 2, n // h
for i in range(0, n, h):
for j in range(hf):
u, v = a[i + j], a[i + j + hf] * w[ut * j]
a[i + j], a[i + j + hf] = (u + v) % p, (u - v) % p
h *= 2
if inverse:
rv = pow(n, p - 2, p)
for i in range(n):
a[i] = a[i] * rv % p
return a
def _number_theoretic_transform(seq, prime, inverse=False):
"""Utility function for the Number Theoretic Transform"""
if not iterable(seq):
raise TypeError("Expected a sequence of integer coefficients "
"for Number Theoretic Transform")
p = as_int(prime)
if isprime(p) == False:
raise ValueError("Expected prime modulus for "
"Number Theoretic Transform")
a = [as_int(x) % p for x in seq]
n = len(a)
if n < 1:
return a
b = n.bit_length() - 1
if n&(n - 1):
b += 1
n = 2**b
if (p - 1) % n:
raise ValueError("Expected prime modulus of the form (m*2**k + 1)")
a += [0]*(n - len(a))
for i in range(1, n):
j = int(ibin(i, b, str=True)[::-1], 2)
if i < j:
a[i], a[j] = a[j], a[i]
pr = primitive_root(p)
rt = pow(pr, (p - 1) // n, p)
if inverse:
rt = pow(rt, p - 2, p)
w = [1]*(n // 2)
for i in range(1, n // 2):
w[i] = w[i - 1]*rt % p
h = 2
while h <= n:
hf, ut = h // 2, n // h
for i in range(0, n, h):
for j in range(hf):
u, v = a[i + j], a[i + j + hf]*w[ut * j]
a[i + j], a[i + j + hf] = (u + v) % p, (u - v) % p
h *= 2
if inverse:
rv = pow(n, p - 2, p)
a = [x*rv % p for x in a]
return a
def test_ibin():
assert ibin(3) == [1, 1]
assert ibin(3, 3) == [0, 1, 1]
assert ibin(3, str=True) == '11'
assert ibin(3, 3, str=True) == '011'
assert list(ibin(2, 'all')) == [(0, 0), (0, 1), (1, 0), (1, 1)]
assert list(ibin(2, 'all', str=True)) == ['00', '01', '10', '11']
def test_ibin():
assert ibin(3) == [1, 1]
assert ibin(3, 3) == [0, 1, 1]
assert ibin(3, str=True) == '11'
assert ibin(3, 3, str=True) == '011'
assert list(ibin(2, 'all')) == [(0, 0), (0, 1), (1, 0), (1, 1)]
assert list(ibin(2, 'all', str=True)) == ['00', '01', '10', '11']
def test_ibin():
assert ibin(3) == [1, 1]
assert ibin(3, 3) == [0, 1, 1]
assert ibin(3, str=True) == "11"
assert ibin(3, 3, str=True) == "011"
assert list(ibin(2, "all")) == [(0, 0), (0, 1), (1, 0), (1, 1)]
assert list(ibin(2, "all", str=True)) == ["00", "01", "10", "11"]
def _fourier_transform(seq, dps, inverse=False):
"""Utility function for the Discrete Fourier Transform (DFT)"""
if not iterable(seq):
raise TypeError("Expected a sequence of numeric coefficients "
"for Fourier Transform")
a = [sympify(arg) for arg in seq]
if any(x.has(Symbol) for x in a):
raise ValueError("Expected non-symbolic coefficients")
n = len(a)
if n < 2:
return a
b = n.bit_length() - 1
if n & (n - 1): # not a power of 2
b += 1
n = 2**b
a += [S.Zero] * (n - len(a))
for i in range(1, n):
j = int(ibin(i, b, str=True)[::-1], 2)
if i < j:
a[i], a[j] = a[j], a[i]
ang = -2 * pi / n if inverse else 2 * pi / n
if dps is not None:
ang = ang.evalf(dps + 2)
w = [cos(ang * i) + I * sin(ang * i) for i in range(n // 2)]
h = 2
while h <= n:
hf, ut = h // 2, n // h
for i in range(0, n, h):
for j in range(hf):
u, v = a[i + j], expand_mul(a[i + j + hf] * w[ut * j])
a[i + j], a[i + j + hf] = u + v, u - v
h *= 2
if inverse:
a = [(x/n).evalf(dps) for x in a] if dps is not None \
else [x/n for x in a]
return a
def _fourier_transform(seq, dps, inverse=False):
"""Utility function for the Discrete Fourier Transform"""
if not iterable(seq):
raise TypeError("Expected a sequence of numeric coefficients "
"for Fourier Transform")
a = [sympify(arg) for arg in seq]
if any(x.has(Symbol) for x in a):
raise ValueError("Expected non-symbolic coefficients")
n = len(a)
if n < 2:
return a
b = n.bit_length() - 1
if n&(n - 1): # not a power of 2
b += 1
n = 2**b
a += [S.Zero]*(n - len(a))
for i in range(1, n):
j = int(ibin(i, b, str=True)[::-1], 2)
if i < j:
a[i], a[j] = a[j], a[i]
ang = -2*pi/n if inverse else 2*pi/n
if dps is not None:
ang = ang.evalf(dps + 2)
w = [cos(ang*i) + I*sin(ang*i) for i in range(n // 2)]
h = 2
while h <= n:
hf, ut = h // 2, n // h
for i in range(0, n, h):
for j in range(hf):
u, v = a[i + j], expand_mul(a[i + j + hf]*w[ut * j])
a[i + j], a[i + j + hf] = u + v, u - v
h *= 2
if inverse:
a = [(x/n).evalf(dps) for x in a] if dps is not None \
else [x/n for x in a]
return a
rhs_string = ""
rhs_template_begin_string = "\n/***********************************************************************************/\n/***********************************************************************************/\n\ntemplate<>\nvoid DoubleAugmentedLagrangianMethodFrictionlessMortarContactCondition<TDim,TNumNodes, TNormalVariation>::CalculateLocalRHS(\n Vector& rLocalRHS,\n const MortarConditionMatrices& rMortarConditionMatrices,\n const DerivativeDataType& rDerivativeData,\n const unsigned int rActiveInactive\n )\n{\n // Initialize values\n // const bounded_matrix<double, TNumNodes, TDim>& u1 = rDerivativeData.u1;\n // const bounded_matrix<double, TNumNodes, TDim>& u2 = rDerivativeData.u2;\n // const bounded_matrix<double, TNumNodes, TDim>& X1 = rDerivativeData.X1;\n // const bounded_matrix<double, TNumNodes, TDim>& X2 = rDerivativeData.X2;\n \n const array_1d<double, TNumNodes>& LMSlaveNormal = MortarUtilities::GetVariableVector<TNumNodes>(this->GetGeometry(), NORMAL_CONTACT_STRESS, 0);\n const array_1d<double, TNumNodes>& LMMasterNormal = MortarUtilities::GetVariableVector<TNumNodes>(this->GetPairedGeometry(), NORMAL_CONTACT_STRESS, 0);\n\n // The ALM parameters\n const double ScaleFactor = rDerivativeData.ScaleFactor;\n // const array_1d<double, TNumNodes>& PenaltyParameter = rDerivativeData.PenaltyParameter;\n \n // Mortar operators\n const bounded_matrix<double, TNumNodes, TNumNodes>& MOperator = rMortarConditionMatrices.MOperator;\n const bounded_matrix<double, TNumNodes, TNumNodes>& DOperator = rMortarConditionMatrices.DOperator;\n\n"
rhs_template_end_string = "\n\n}\n"
for normalvar in range(2):
if normalvar == 0:
normalvarstring = "false"
else:
normalvarstring = "true"
for dim, nnodes in zip(dim_combinations, nnodes_combinations):
from sympy.utilities.iterables import ibin
active_inactive_combinations = list(ibin(nnodes, 'all'))
active_inactive_comb = 0
for active_inactive in active_inactive_combinations: # Change output in combination of this
active_inactive_comb += 1
number_dof = dim * (2 * nnodes) + 2 * nnodes
#Defining the unknowns
u1 = DefineMatrix(
'u1', nnodes, dim
) #u1(i,j) is displacement of node i component j at domain 1
u2 = DefineMatrix(
'u2', nnodes, dim
) #u2(i,j) is displacement of node i component j at domain 2
def create_indices(arr):
indices = list(ibin(len(arr), 'all'))
return indices
