# Python math.pow() Examples

The following are 30 code examples of math.pow(). You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may also want to check out all available functions/classes of the module , or try the search function .
Example #1
```def calculate_similarity(text1,text2):
raw1 = jieba.cut(text1)
raw2 = jieba.cut(text2)
raw1 = Counter(raw1)
raw2 = Counter(raw2)
same_words = set(raw1) & set(raw2)
if (math.sqrt(len(raw1)) * math.sqrt(len(raw2))) != 0:
dot_product = 0
mod1 = 0
mod2 = 0
for word in same_words:
dot_product += raw1[word] * raw2[word]
for word in raw1:
mod1 += math.pow(raw1[word],2)
for word in raw2:
mod2 += math.pow(raw2[word],2)
cos = dot_product/math.sqrt(mod1*mod2)
else:
cos = 0
return cos ```
Example #2
```def swirl(x, y, step):
x -= (u_width / 2)
y -= (u_height / 2)
dist = math.sqrt(pow(x, 2) + pow(y, 2)) / 2.0
angle = (step / 10.0) + (dist * 1.5)
s = math.sin(angle)
c = math.cos(angle)
xs = x * c - y * s
ys = x * s + y * c
r = abs(xs + ys)
r = r * 12.0
r -= 20
return (r, r + (s * 130), r + (c * 130))

# roto-zooming checker board ```
Example #3
```def setValue(self, settings, e):
if e.index == 1:
self.logicalName = _GXCommon.toLogicalName(e.value)
elif e.index == 2:
if self.scaler != 1 and e.value is not None:
try:
if settings.isServer:
self.value = e.value
else:
self.value = e.value * self.scaler
except Exception:
#  Sometimes scaler is set for wrong Object type.
self.value = e.value
else:
self.value = e.value
elif e.index == 3:
#  Set default values.
if not e.value:
self.scaler = 1
self.unit = Unit.NONE
else:
self.scaler = math.pow(10, e.value[0])
self.unit = Unit(e.value[1])
else:
Example #4
```def _compute_dE(self, pos=None, lengths=None, weights=None, m=None):
dEx = 0
dEy = 0
d2Ex2 = 0
d2Ey2 = 0
d2Exy = 0
d2Eyx = 0
for i in pos:
if i != m:
xmi = pos[m][0] - pos[i][0]
ymi = pos[m][1] - pos[i][1]
xmi2 = xmi * xmi
ymi2 = ymi * ymi
xmi_ymi2 = xmi2 + ymi2
lmi = lengths[m][i]
kmi = weights[m][i] / (lmi * lmi)
dEx += kmi * (xmi - (lmi * xmi) / math.sqrt(xmi_ymi2))
dEy += kmi * (ymi - (lmi * ymi) / math.sqrt(xmi_ymi2))
d2Ex2 += kmi * (1 - (lmi * ymi2) / math.pow(xmi_ymi2, 1.5))
d2Ey2 += kmi * (1 - (lmi * xmi2) / math.pow(xmi_ymi2, 1.5))
res = kmi * (lmi * xmi * ymi) / math.pow(xmi_ymi2, 1.5)
d2Exy += res
d2Eyx += res
return dEx, dEy, d2Ex2, d2Ey2, d2Exy, d2Eyx ```
Example #5
```def genCubeVector(x, y, z, x_mult=1, y_mult=1, z_mult=1):
"""Generates a map of vector lengths from the center point to each coordinate

x - width of matrix to generate
y - height of matrix to generate
z - depth of matrix to generate
x_mult - value to scale x-axis by
y_mult - value to scale y-axis by
z_mult - value to scale z-axis by
"""
cX = (x - 1) / 2.0
cY = (y - 1) / 2.0
cZ = (z - 1) / 2.0

def vect(_x, _y, _z):
return int(math.sqrt(math.pow(_x - cX, 2 * x_mult) +
math.pow(_y - cY, 2 * y_mult) +
math.pow(_z - cZ, 2 * z_mult)))

return [[[vect(_x, _y, _z) for _z in range(z)] for _y in range(y)] for _x in range(x)] ```
Example #6
```def _free_space(self, directory, power=0):
"""
Get available free space at a target directory.

@param directory: directory path of a folder
@type directory: basestring

@return: Available free space
@rtype: float
"""
assert power >= 0
assert isinstance(directory, basestring)
assert self.validate_dir(directory)
if not directory or not os.path.isdir(directory):
return 0
statvfs = os.statvfs(directory)
free_space = statvfs.f_frsize * statvfs.f_bfree
return free_space / math.pow(1024, power) ```
Example #7
```def _load_data(name):
tks = buf.split(' ')
vocab = {}
freq = [0]
data = []
for tk in tks:
if len(tk) == 0:
continue
if tk not in vocab:
vocab[tk] = len(vocab) + 1
freq.append(0)
wid = vocab[tk]
data.append(wid)
freq[wid] += 1
negative = []
for i, v in enumerate(freq):
if i == 0 or v < 5:
continue
v = int(math.pow(v * 1.0, 0.75))
negative += [i for _ in range(v)]
return data, negative, vocab, freq ```
Example #8
```def __call__(self, iteration):
"""
Call to schedule current learning rate.

Parameters
----------
iteration: int
Current iteration count.
"""

if not self.init:
self.init = True
self.old_lr = self.base_lr
lr = self.base_lr * math.pow(self.factor, int(iteration / self.step))
if lr != self.old_lr:
self.old_lr = lr
logging.info("At Iteration [%d]: Swith to new learning rate %.5f",
iteration, lr)
return lr ```
Example #9
```def _gaussian(
size=3, sigma=0.25, amplitude=1, normalize=False, width=None,
height=None, sigma_horz=None, sigma_vert=None, mean_horz=0.5,
mean_vert=0.5):
# handle some defaults
if width is None:
width = size
if height is None:
height = size
if sigma_horz is None:
sigma_horz = sigma
if sigma_vert is None:
sigma_vert = sigma
center_x = mean_horz * width + 0.5
center_y = mean_vert * height + 0.5
gauss = np.empty((height, width), dtype=np.float32)
# generate kernel
for i in range(height):
for j in range(width):
gauss[i][j] = amplitude * math.exp(-(math.pow((j + 1 - center_x) / (
sigma_horz * width), 2) / 2.0 + math.pow((i + 1 - center_y) / (sigma_vert * height), 2) / 2.0))
if normalize:
gauss = gauss / np.sum(gauss)
return gauss ```
Example #10
```def rampweight(iteration):
ramp_up_end = 32000
ramp_down_start = 100000

if(iteration<ramp_up_end):
ramp_weight = math.exp(-5 * math.pow((1 - iteration / ramp_up_end),2))
elif(iteration>ramp_down_start):
ramp_weight = math.exp(-12.5 * math.pow((1 - (120000 - iteration) / 20000),2))
else:
ramp_weight = 1

if(iteration==0):
ramp_weight = 0

return ramp_weight ```
Example #11
```def pow(requestContext, seriesList, factor):
"""
Takes one metric or a wildcard seriesList followed by a constant, and raises the datapoint
by the power of the constant provided at each point.

Example:

.. code-block:: none

"""
yield defer.succeed(None)
for series in seriesList:
series.name = "pow(%s,%g)" % (series.name, float(factor))
series.pathExpression = series.name
for i, value in enumerate(series):
series[i] = safePow(value, factor)
returnValue(seriesList) ```
Example #12
```def nChooseK(n, k):
# is n an integer?
nInt = (math.floor(n) == n)
if n == k or k == 0:
return 1
if (n < k) or (k < 0):
raise Exception
if (nInt) and (n < 0.0):
b = pow(-1.0, k) * math.exp(math.lgamma(abs(n + k)) \
- math.lgamma(k + 1.0)    \
- math.lgamma(abs(n)))
return round(b)
if (n >= k):
b = math.exp(math.lgamma(n + 1.0) - math.lgamma(k + 1.0) \
- math.lgamma(n - k + 1.0))
return round(b)
if not (nInt) and (n < k):
b = (1.0/math.pi) * math.exp(math.lgamma(n + 1.0) \
- math.lgamma(k + 1)   \
+ math.lgamma(k - n)   \
+ math.log(math.sin(math.pi * (n - k + 1.0))))
return round(b)
return 0.0 ```
Example #13
```def _gaussian(
size=3, sigma=0.25, amplitude=1, normalize=False, width=None,
height=None, sigma_horz=None, sigma_vert=None, mean_horz=0.5,
mean_vert=0.5):
# handle some defaults
if width is None:
width = size
if height is None:
height = size
if sigma_horz is None:
sigma_horz = sigma
if sigma_vert is None:
sigma_vert = sigma
center_x = mean_horz * width + 0.5
center_y = mean_vert * height + 0.5
gauss = np.empty((height, width), dtype=np.float32)
# generate kernel
for i in range(height):
for j in range(width):
gauss[i][j] = amplitude * math.exp(-(math.pow((j + 1 - center_x) / (
sigma_horz * width), 2) / 2.0 + math.pow((i + 1 - center_y) / (sigma_vert * height), 2) / 2.0))
if normalize:
gauss = gauss / np.sum(gauss)
return gauss ```
Example #14
```def push(self, time, tput, lat):
global throughput
global latency

for i in range(len(self.half_life)):
alpha = math.pow(0.5, time / self.half_life[i])
self.throughput[i] = alpha * self.throughput[i] + (1 - alpha) * tput
alpha = math.pow(0.5, 1 / self.latency_half_life[i])
self.latency[i] = alpha * self.latency[i] + (1 - alpha) * lat

self.weight_throughput += time
self.weight_latency += 1

tput = None
lat = None
for i in range(len(self.half_life)):
zero_factor = 1 - math.pow(0.5, self.weight_throughput / self.half_life[i])
t = self.throughput[i] / zero_factor
tput = t if tput == None else min(tput, t)  # conservative case is min
zero_factor = 1 - math.pow(0.5, self.weight_latency / self.latency_half_life[i])
l = self.latency[i] / zero_factor
lat = l if lat == None else max(lat, l) # conservative case is max
throughput = tput
latency = lat ```
Example #15
```def push(self, time, tput, lat):
global throughput
global latency

for i in range(len(self.half_life)):
alpha = math.pow(0.5, time / self.half_life[i])
self.throughput[i] = alpha * self.throughput[i] + (1 - alpha) * tput
alpha = math.pow(0.5, 1 / self.latency_half_life[i])
self.latency[i] = alpha * self.latency[i] + (1 - alpha) * lat

self.weight_throughput += time
self.weight_latency += 1

tput = None
lat = None
for i in range(len(self.half_life)):
zero_factor = 1 - math.pow(0.5, self.weight_throughput / self.half_life[i])
t = self.throughput[i] / zero_factor
tput = t if tput == None else min(tput, t)  # conservative case is min
zero_factor = 1 - math.pow(0.5, self.weight_latency / self.latency_half_life[i])
l = self.latency[i] / zero_factor
lat = l if lat == None else max(lat, l) # conservative case is max
throughput = tput
latency = lat ```
Example #16
```def push(self, time, tput, lat):
global throughput
global latency

for i in range(len(self.half_life)):
alpha = math.pow(0.5, time / self.half_life[i])
self.throughput[i] = alpha * self.throughput[i] + (1 - alpha) * tput
alpha = math.pow(0.5, 1 / self.latency_half_life[i])
self.latency[i] = alpha * self.latency[i] + (1 - alpha) * lat

self.weight_throughput += time
self.weight_latency += 1

tput = None
lat = None
for i in range(len(self.half_life)):
zero_factor = 1 - math.pow(0.5, self.weight_throughput / self.half_life[i])
t = self.throughput[i] / zero_factor
tput = t if tput == None else min(tput, t)  # conservative case is min
zero_factor = 1 - math.pow(0.5, self.weight_latency / self.latency_half_life[i])
l = self.latency[i] / zero_factor
lat = l if lat == None else max(lat, l) # conservative case is max
throughput = tput
latency = lat ```
Example #17
```def human_readable_size(size_bytes):
"""Gets a number of bytes as a human readable string.

Args:
size_bytes (:obj:`int`): The number of bytes to get as human readable.

Returns:
:obj:`str`: The number of bytes in a human readable form.
"""
if size_bytes == 0:
return "0B"
size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
base = int(math.floor(math.log(size_bytes, 1024)))
power = math.pow(1024, base)
size = round(size_bytes / power, 2)
return "%s %s" % (size, size_name[base]) ```
Example #18
```def genVector(width, height, x_mult=1, y_mult=1):
"""
Generates a map of vector lengths from the center point to each coordinate.

width - width of matrix to generate
height - height of matrix to generate
x_mult - value to scale x-axis by
y_mult - value to scale y-axis by
"""
center_x = (width - 1) / 2
center_y = (height - 1) / 2

def length(x, y):
dx = math.pow(x - center_x, 2 * x_mult)
dy = math.pow(y - center_y, 2 * y_mult)
return int(math.sqrt(dx + dy))

return [[length(x, y) for x in range(width)] for y in range(height)] ```
Example #19
```def tunnel(x, y, step):
speed = step / 100.0
x -= (u_width / 2)
y -= (u_height / 2)
xo = math.sin(step / 27.0) * 2
yo = math.cos(step / 18.0) * 2
x += xo
y += yo
if y == 0:
if x < 0:
angle = -(math.pi / 2)
else:
angle = (math.pi / 2)
else:
angle = math.atan(x / y)
if y > 0:
angle += math.pi
angle /= 2 * math.pi  # convert angle to 0...1 range
hyp = math.sqrt(math.pow(x, 2) + math.pow(y, 2))
angle += speed
depth = speed + (hyp / 10)
col1 = hue_to_rgb[step % 255]
col1 = (col1[0] * 0.8, col1[1] * 0.8, col1[2] * 0.8)
col2 = hue_to_rgb[step % 255]
col2 = (col2[0] * 0.3, col2[1] * 0.3, col2[2] * 0.3)
col = col1 if int(abs(angle * 6.0)) % 2 == 0 else col2
td = .3 if int(abs(depth * 3.0)) % 2 == 0 else 0
col = (col[0] + td, col[1] + td, col[2] + td)
return (col[0] * 255, col[1] * 255, col[2] * 255) ```
Example #20
```def setValue(self, settings, e):
if e.index == 1:
self.logicalName = _GXCommon.toLogicalName(e.value)
elif e.index == 2:
if self.scaler != 1 and e.value:
try:
if settings.isServer:
self.value = e.value
else:
self.value = e.value * self.scaler
except Exception:
#  Sometimes scaler is set for wrong Object type.
self.value = e.value
else:
self.value = e.value
elif e.index == 3:
#  Set default values.
if not e.value:
self.scaler = 0
self.unit = Unit.NONE
else:
if not e.value:
self.scaler = 0
self.unit = Unit.NONE
else:
self.scaler = math.pow(10, e.value[0])
self.unit = Unit(e.value[1])
elif e.index == 4:
self.status = e.value
elif e.index == 5:
if e.value is None:
self.captureTime = GXDateTime()
else:
if isinstance(e.value, bytearray):
self.captureTime = _GXCommon.changeType(settings, e.value, DataType.DATETIME)
else:
self.captureTime = e.value
else:
Example #21
```def bleu(pred_tokens, label_tokens, k):
len_pred, len_label = len(pred_tokens), len(label_tokens)
score = math.exp(min(0, 1 - len_label / len_pred))
for n in range(1, k + 1):
num_matches, label_subs = 0, collections.defaultdict(int)
for i in range(len_label - n + 1):
label_subs[''.join(label_tokens[i: i + n])] += 1
for i in range(len_pred - n + 1):
if label_subs[''.join(pred_tokens[i: i + n])] > 0:
num_matches += 1
label_subs[''.join(pred_tokens[i: i + n])] -= 1
score *= math.pow(num_matches / (len_pred - n + 1), math.pow(0.5, n))
return score ```
Example #22
```def logmgf_exact(q, priv_eps, l):
"""Computes the logmgf value given q and privacy eps.

The bound used is the min of three terms. The first term is from
https://arxiv.org/pdf/1605.02065.pdf.
The second term is based on the fact that when event has probability (1-q) for
q close to zero, q can only change by exp(eps), which corresponds to a
much smaller multiplicative change in (1-q)
The third term comes directly from the privacy guarantee.
Args:
q: pr of non-optimal outcome
priv_eps: eps parameter for DP
l: moment to compute.
Returns:
Upper bound on logmgf
"""
if q < 0.5:
t_one = (1-q) * math.pow((1-q) / (1 - math.exp(priv_eps) * q), l)
t_two = q * math.exp(priv_eps * l)
t = t_one + t_two
try:
log_t = math.log(t)
except ValueError:
print "Got ValueError in math.log for values :" + str((q, priv_eps, l, t))
log_t = priv_eps * l
else:
log_t = priv_eps * l

return min(0.5 * priv_eps * priv_eps * l * (l + 1), log_t, priv_eps * l) ```
Example #23
```def cal_line_length(point1, point2):
return math.sqrt( math.pow(point1[0] - point2[0], 2) + math.pow(point1[1] - point2[1], 2)) ```
Example #24
```def train(epoch, model, source_loader, target_loader):
#最后的全连接层学习率为前面的10倍
LEARNING_RATE = args.lr / math.pow((1 + 10 * (epoch - 1) / args.epochs), 0.75)
print("learning rate：", LEARNING_RATE)
if args.diff_lr:
optimizer = torch.optim.SGD([
{'params': model.sharedNet.parameters()},
{'params': model.Inception.parameters(), 'lr': LEARNING_RATE},
], lr=LEARNING_RATE / 10, momentum=args.momentum, weight_decay=args.l2_decay)
else:
optimizer = optim.SGD(model.parameters(), lr=LEARNING_RATE, momentum=args.momentum,weight_decay = args.l2_decay)
model.train()
for batch_idx, (source_data, source_label) in enumerate(source_loader):
try:
target_data, _ = tgt_iter.next()
except Exception as err:
target_data, _ = tgt_iter.next()

if args.cuda:
source_data, source_label = source_data.cuda(), source_label.cuda()
target_data = target_data.cuda()

s_output, mmd_loss = model(source_data, target_data, source_label)
soft_loss = F.nll_loss(F.log_softmax(s_output, dim=1), source_label)
# print((2 / (1 + math.exp(-10 * (epoch) / args.epochs)) - 1))
if args.gamma == 1:
gamma = 2 / (1 + math.exp(-10 * (epoch) / args.epochs)) - 1
if args.gamma == 2:
gamma = epoch /args.epochs
loss = soft_loss + gamma * mmd_loss
loss.backward()
optimizer.step()
if batch_idx % args.log_interval == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tlabel_Loss: {:.6f}\tmmd_Loss: {:.6f}'.format(
100. * batch_idx / len(train_loader), loss.item(), soft_loss.item(), mmd_loss.item())) ```
Example #25
```def point_distance(p1, p2):
"""Return the distance between two points."""
delta_x = p2.x - p1.x
delta_y = p2.y - p1.y
return sqrt(pow(delta_x, 2.0) + pow(delta_y, 2.0)),

# Another function used to define of one of our custom instructions. ```
Example #26
```def point_distance(p1, p2):
delta_x = p2.x - p1.x
delta_y = p2.y - p1.y
return sqrt(pow(delta_x, 2.0) + pow(delta_y, 2.0)), ```
Example #27
```def point_distance(p1, p2):
delta_x = p2.x - p1.x
delta_y = p2.y - p1.y
return sqrt(pow(delta_x, 2.0) + pow(delta_y, 2.0)) ```
Example #28
```def pow(a, b=2):
try:
return math.pow(a, b)
except OverflowError:
return float('inf')

# Also known as logist or logistic ```
Example #29
```def safePow(a, b):
if a is None:
return None
try:
result = math.pow(a, b)
except ValueError:
return None
return result ```
Example #30
```def calculate_pplx(self, path, val=True):
""" Splits the input data into batches of self.args.batch_size to
reduce the memory footprint of holding all of the data in RAM. """

prefix = "val" if val else "test"
logger.info("Calculating pplx over %s data", prefix)
sum_logprobs = 0
y_len = 0

generator = self.data_gen.generation_generator(prefix)
seen = 0
for data in generator:
Y_target = deepcopy(data[1]['output'])
del data[1]['output']

preds = self.model.predict(data[0],
verbose=0,
batch_size=self.args.batch_size)

for i in range(Y_target.shape[0]):
for t in range(Y_target.shape[1]):
target_idx = np.argmax(Y_target[i, t])
target_tok = self.index2word[target_idx]
if target_tok != "<P>":
log_p = math.log(preds[i, t, target_idx],2)
sum_logprobs += -log_p
y_len += 1

seen += data[0]['text'].shape[0]
if seen == self.data_gen.split_sizes[prefix]:
# Hacky way to break out of the generator
break

norm_logprob = sum_logprobs / y_len
pplx = math.pow(2, norm_logprob)
logger.info("PPLX: %.4f", pplx)
handle = open("%s/%sPPLX" % (path, prefix), "w")
handle.write("%f\n" % pplx)
handle.close()
return pplx ```