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 _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