text stringlengths 38 1.54M |
|---|
import os
import multiprocessing
# Properties
daemon = True
workers = multiprocessing.cpu_count() * 2 + 1
# Setup server
ip = os.environ['OPENSHIFT_GEO_IP']
port = os.environ['OPENSHIFT_GEO_PORT']
bind = '{}:{}'.format(ip, port)
|
import asyncio
import json
import websockets
async def consumer_handler(frames):
async for frame in frames:
trade = json.loads(frame)
print(trade)
async def connect():
async with websockets.connect("wss://stream.binance.com:9443/ws/btcusdt@trade") as ws:
await consumer_handler(ws)
if __name__ == '__main__':
loop = asyncio.get_event_loop()
loop.run_until_complete(connect())
loop.run_forever()
|
# Authors: Nanda H Krishna (https://github.com/nandahkrishna), Abhijith Ragav (https://github.com/abhijithragav)
import os
from datetime import *
from dateutil.relativedelta import *
from dateutil.rrule import *
import json
import requests
import threading
from flask import Flask, jsonify, render_template, request
import slack
from slackeventsapi import SlackEventAdapter
import pyrebase
app = Flask(__name__)
app.debug = True
tars_admin = os.environ.get("TARS_ADMIN")
tars_token = os.environ.get("TARS_TOKEN")
tars_secret = os.environ.get("TARS_SECRET")
tars_bot_id = os.environ.get("TARS_BOT_ID")
general_id = os.environ.get("GENERAL_ID")
vineethv_id = os.environ.get("VINEETHV_ID")
firebase_api_key = os.environ.get("FIREBASE_API_KEY")
tars = slack.WebClient(token=tars_token)
slack_events_adapter = SlackEventAdapter(tars_secret, "/event", app)
vineethv_im_request = tars.im_open(user=vineethv_id)
vineethv_im_channel = vineethv_im_request.data["channel"]["id"]
config = {
"apiKey": firebase_api_key,
"authDomain": "sf-tars.firebaseapp.com",
"databaseURL": "https://sf-tars.firebaseio.com/",
"storageBucket": "sf-tars.appspot.com"
}
firebase = pyrebase.initialize_app(config)
@app.route("/", methods=["GET"])
def index():
return render_template("index.html")
@slack_events_adapter.on("message")
def message(event_data):
thread = threading.Thread(target=im_event_handler, args=(event_data,))
thread.start()
return "", 200
def im_event_handler(event_data):
text = event_data["event"]["text"].lower()
if "request office hours" in text:
tars.chat_postMessage(channel=vineethv_im_channel, text="Sir, please fill your office hours in this form: https://forms.gle/eMoayTXg5KJCata68")
if "post office hours" in text:
db = firebase.database()
data = db.get().val()
data = data[list(data.keys())[0]]
message = "Sir's office hours for the week:\n"
for item in data[1:]:
item["start"] = reformat_time(item["start"])
item["end"] = reformat_time(item["end"])
message += item["days"] + ": " + item["start"] + " - " + item["end"] + "\n"
tars.chat_postMessage(channel=general_id, text=message)
def reformat_time(ts):
hour = int(ts.split(":")[0][-2:]) + 5
min = int(ts.split(":")[1][:2]) + 22
if min >= 60:
min -= 60
hour += 1
time = ""
if len(str(min)) == 1:
min = "0" + str(min)
if hour >= 12:
if hour != 12:
hour -= 12
time = str(hour) + ":" + str(min) + " PM"
else:
time = str(hour) + ":" + str(min) + " AM"
return time
if __name__ == "__main__":
app.run()
|
from cdat import vcswidget
import vcs
class FillPreviewWidget(vcswidget.QVCSWidget):
def __init__(self, parent=None):
super(FillPreviewWidget, self).__init__(parent=parent)
self.fillobj = None
def setFillObject(self, fillobject):
self.fillobj = fillobject
tmpobj = vcs.createfillarea(source=self.fillobj)
tmpobj.x = [.25, .25, .75, .75]
tmpobj.y = [.25, .75, .75, .25]
self.clear()
self.plot(tmpobj)
def update(self):
self.setFillObject(self.fillobj)
|
from django.shortcuts import render,redirect
from .models import Question,Choice
from django.contrib import messages
# Create your views here.
def home(request):
question = Question.objects.all()
messages.success(request, " | Vote Now!")
return render(request, 'pollapp/home.html', {'question':question})
def vote(request, pk):
question = Question.objects.get(id=pk)
try:
choice = question.choice_set.get(id=request.POST['choice'])
except(KeyError):
print("Failed to vote")
else:
choice.votes +=1
choice.save()
messages.success(request, " You Successfully Vote")
return redirect("home")
return render(request, 'pollapp/vote.html', {'question':question})
def result(request, pk):
question = Question.objects.get(id = pk)
return render(request, 'pollapp/results.html', {'question':question})
|
print("#"*1)
print("#"*2)
print("#"*3)
print("#"*4)
print("#"*5)
for item in list(range(1,6,1)):
print("#"*item)
|
#Identifica se os números de 1 a 9 qual é primo,
for n in range(2,10):
for x in range(2,n):
if n % x == 0:
print(n, 'igual a', x, '*',n // x)
break
else:
print(n, 'é número primo') |
# coding: utf-8
import math
import numpy as np
from collections import Counter
import torch
import torch.nn.init as init
from torch import nn
from torch.autograd import Variable
#####################################################################################################################
def batch(iterable, n=1):
l = len(iterable)
for ndx in range(0, l, n):
yield iterable[ndx:min(ndx + n, l)]
#####################################################################################################################
def mini_batch(X, Y, n, shuffle=False):
X_iterable, Y_iterable = X, Y
l = len(X)
for ndx in range(0, l, n):
if shuffle:
idx_data = np.random.permutation(min(ndx + n, l) - ndx)
yield X_iterable[ndx:min(ndx + n, l)][idx_data], Y_iterable[ndx:min(ndx + n, l)][idx_data]
else:
yield X_iterable[ndx:min(ndx + n, l)], Y_iterable[ndx:min(ndx + n, l)]
#####################################################################################################################
def exp_decay (epoch):
return 0.5 * 1 / (1 + epoch * 0.5 )
def exp_decay1(epoch):
lr = 0.2
lr_g = 0.05
lr_b = 0.75
return lr * (1 + epoch * lr_g )**-lr_b
def step_decay(epoch):
lr = 0.2
lr_drop = 0.78 # factor / percent to drop
lr_epochs_drop = 16.0 # no of epochs after which to drop lr
lr_min = 0.01
return max( lr * math.pow(lr_drop, math.floor((1 + epoch) / lr_epochs_drop)), lr_min)
# lambda epoch: max(math.pow(0.78, math.floor((1 + epoch) / 11.0)), 0.4)
#####################################################################################################################
def to_np(x):
return x.data.cpu().numpy()
def to_var(x, async=False):
if torch.cuda.is_available():
x = x.cuda(async=async)
return Variable(x)
###################################################################################################################
from imblearn.base import *
from imblearn.utils import check_ratio, check_target_type, hash_X_y
import logging
class OutlierSampler(SamplerMixin):
def __init__(self, threshold=1.5, memory=None, verbose=0):
self.threshold = threshold
self.verbose = verbose
self.logger = logging.getLogger(__name__)
def sample(self, X, y):
# Check the consistency of X and y
X, y = check_X_y(X, y, accept_sparse=['csr', 'csc'])
check_is_fitted(self, 'X_hash_')
self._check_X_y(X, y)
X_out, y_out = self._sample(X, y)
return X_out, y_out
def _sample(self, X, y):
outliers = []
for col in X.T: # loop over feature columns
Q1 = np.percentile(col, 25) # Calculate Q1 (25th percentile of the data) for the given feature
Q3 = np.percentile(col, 75) # Calculate Q3 (75th percentile of the data) for the given feature
step = self.threshold * (Q3 - Q1) # Use the interquartile range to calculate an outlier step
feature_outliers = np.where(~((col >= Q1 - step) & (col <= Q3 + step)))[0]
outliers.extend(feature_outliers)
# Find the data points that where considered outliers for more than one feature
multi_feature_outliers = list((Counter(outliers) - Counter(set(outliers))).keys())
X_out = np.delete(X, multi_feature_outliers, axis=0)
y_out = np.delete(y, multi_feature_outliers, axis=0)
if self.verbose:
print('Sampled - reduced points form / to: ', X.shape, X_out.shape)
return X_out, y_out
def fit(self, X, y):
X, y = check_X_y(X, y, accept_sparse=['csr', 'csc'])
y = check_target_type(y)
self.X_hash_, self.y_hash_ = hash_X_y(X, y)
self._fit( X, y)
return self
def _fit(self, X, y):
if self.verbose:
print('OutlierSampler Fitted X/y: ', X.shape, y.shape)
return self
def fit_sample(self, X, y):
return self.fit(X, y).sample(X, y)
#######################################################################################################################
# https://gist.github.com/jeasinema/ed9236ce743c8efaf30fa2ff732749f5
def torch_weight_init(m):
"""
Usage:
model = Model()
model.apply(weight_init)
"""
if isinstance(m, nn.Conv1d):
init.normal(m.weight.data)
init.normal(m.bias.data)
elif isinstance(m, nn.Conv2d):
init.xavier_normal(m.weight.data)
init.normal(m.bias.data)
elif isinstance(m, nn.Conv3d):
init.xavier_normal(m.weight.data)
init.normal(m.bias.data)
elif isinstance(m, nn.ConvTranspose1d):
init.normal(m.weight.data)
init.normal(m.bias.data)
elif isinstance(m, nn.ConvTranspose2d):
init.xavier_normal(m.weight.data)
init.normal(m.bias.data)
elif isinstance(m, nn.ConvTranspose3d):
init.xavier_normal(m.weight.data)
init.normal(m.bias.data)
elif isinstance(m, nn.BatchNorm1d):
init.normal(m.weight.data, mean=1, std=0.02)
init.constant(m.bias.data, 0)
elif isinstance(m, nn.BatchNorm2d):
init.normal(m.weight.data, mean=1, std=0.02)
init.constant(m.bias.data, 0)
elif isinstance(m, nn.BatchNorm3d):
init.normal(m.weight.data, mean=1, std=0.02)
init.constant(m.bias.data, 0)
elif isinstance(m, nn.Linear):
init.xavier_normal(m.weight.data)
init.normal(m.bias.data)
elif isinstance(m, nn.LSTM):
for param in m.parameters():
if len(param.shape) >= 2:
init.orthogonal(param.data)
else:
init.normal(param.data)
elif isinstance(m, nn.LSTMCell):
for param in m.parameters():
if len(param.shape) >= 2:
init.orthogonal(param.data)
else:
init.normal(param.data)
elif isinstance(m, nn.GRU):
for param in m.parameters():
if len(param.shape) >= 2:
init.orthogonal(param.data)
else:
init.normal(param.data)
elif isinstance(m, nn.GRUCell):
for param in m.parameters():
if len(param.shape) >= 2:
init.orthogonal(param.data)
else:
init.normal(param.data)
####################################################################################################################### |
from django.apps import AppConfig
from django.db.models.signals import post_save, post_delete
from django.conf import settings
class ProductConfig(AppConfig):
name = 'utilities.product'
def ready(self):
import drf_nest.signals
from utilities.product.models import ProductOffering
from utilities.product.serializers import ProductOfferingSerializer
exchange_prefix = settings.MQ_FRAMEWORK['EXCHANGE_PREFIX'] + self.name
exchange_header_list = ('status',)
post_save.connect( drf_nest.signals.notify_extra_args( serializer=ProductOfferingSerializer,
exchange_prefix=exchange_prefix + ".ProductOffering",
exchange_header_list=exchange_header_list)(drf_nest.signals.notify_save_instance),
sender=ProductOffering, weak=False)
|
class Solution:
"""
@param m: An integer m denotes the size of a backpack
@param A: Given n items with size A[i]
@return: The maximum size
"""
def backPack(self, m, A):
# write your code here
n = len(A)
res = [[False] * (m + 1) for _ in range(n + 1)]
for i in range(n + 1):
res[i][0] = True
for w in range(1, m + 1):
if w >= A[i - 1]:
res[i][w] = res[i - 1][w] or res[i - 1][w - A[i - 1]]
else:
res[i][w] = res[i - 1][w]
for index, elem in enumerate(res[n][::-1]):
if elem:
return len(res[n]) - 1 - index
|
from __future__ import unicode_literals
import os
import importlib
import six
import cherrypy
from sideboard._version import __version__
import sideboard.server
from sideboard.internal.imports import _discover_plugins
from sideboard.internal.logging import _configure_logging
import sideboard.run_mainloop
if 'SIDEBOARD_MODULE_TESTING' not in os.environ:
_discover_plugins()
_configure_logging()
|
#!/usr/bin/python
import os
import sys
import re
property_seperator = '='
def print_error(msg):
print "[ERROR] %s" % msg
sys.exit(1)
def print_usage():
print "[USAGE] python migrate_gradle.py {project_folder_path}"
def read_property_file(f):
props = {}
for line in f:
if property_seperator in line and (not line.strip().startswith("#")):
name, value = line.split(property_seperator, 1)
props[name.strip()] = value.strip()
return props
def get_bool_value_from_props(props, name, default = False):
if name in props:
return props[name] == "true"
else:
return default
def get_string_value_from_props(props, name, default = None):
if name in props:
return props[name]
else:
return default
def get_android_dependencies(props):
android_dependencies = []
i = 1
while ("android.library.reference.%d" % i) in props:
android_dependencies.append(props["android.library.reference.%d" % i])
i = i + 1
return android_dependencies
def replace_single_line_with_property(line, key, props):
value = props[key]
if type(value) is list:
head_white_space = ""
while len(head_white_space) < len(line) and line[len(head_white_space)] == " ":
head_white_space = head_white_space + " "
lines = []
for single_value in value:
if len(lines) == 0:
lines.append(re.sub(r"##%s##" % key, "%s" % single_value, line))
else:
lines.append("%s%s" % (head_white_space, single_value))
return lines
else:
return re.sub(r"##%s##" % key, "%s" % value, line)
def replace_line_with_property(line, key, props):
if type(line) is list:
lines = []
for single_line in line:
lines.extend(replace_single_line_with_property(single_line, key, props))
return lines
else:
return replace_single_line_with_property(line, key, props)
def read_template_lines_by_replacing_props(template_path, props):
if not os.path.exists(template_path):
print_error("template file not found: %s" % template_path)
return
template_file = open(template_path)
out_lines = []
for line in template_file:
replaced_lines = [line]
groups = re.findall(r'##(\w+)##', line)
if (not groups == None) and len(groups) > 0:
for group in groups:
if group in props:
replaced_lines = replace_line_with_property(replaced_lines, group, props)
out_lines.extend(replaced_lines)
template_file.close()
return out_lines
def handle_project_properties_file(file_path, local_dict):
if not os.path.exists(file_path):
print_error("invalid android project: project.properties file not found: %s" % file_path)
return
project_property_file = open(file_path)
project_property_props = read_property_file(project_property_file)
project_property_file.close()
local_dict["module_android_library"] = get_bool_value_from_props(project_property_props, "android.library")
local_dict["module_target"] = get_string_value_from_props(project_property_props, "target")
local_dict["module_proguard_cfg"] = get_string_value_from_props(project_property_props, "proguard.cfg")
local_dict["module_dex_force_jumbo"] = get_bool_value_from_props(project_property_props, "dex.force.jumbo")
deps = get_android_dependencies(project_property_props)
local_dict["module_deps"] = deps
def travesal_project_properties_from_dir(dir_path, global_dict):
if global_dict == None:
return
if dir_path in global_dict:
return
global_dict[dir_path] = {}
global_dict[dir_path]["module_name"] = os.path.basename(os.path.abspath(dir_path))
# retrieve project.properties
project_property_path = os.path.join(dir_path, "project.properties")
handle_project_properties_file(project_property_path, global_dict[dir_path])
# travesal dependencies
for dep_path in global_dict[dir_path]["module_deps"]:
travesal_project_properties_from_dir(os.path.join(dir_path, dep_path), global_dict)
def generate_module_build_gradle_file(dir_path, local_dict):
module_props_for_replace = {}
module_dependency_list = []
for dep_path in local_dict["module_deps"]:
module_dependency_list.append("compile project(':%s')" % _global_module_property_dict[os.path.join(dir_path, dep_path)]["module_name"])
module_props_for_replace["module_dependencies"] = module_dependency_list
generated_lines = []
if local_dict["module_android_library"]:
generated_lines = read_template_lines_by_replacing_props(os.path.join(os.path.dirname(__file__), "./templates/build.gradle.template.library"), module_props_for_replace)
else:
root_template_file = open(os.path.join(os.path.dirname(__file__), "./templates/build.gradle.template.root"))
for line in root_template_file:
generated_lines.append(line)
root_template_file.close()
generated_lines.append("\n")
generated_lines.extend(read_template_lines_by_replacing_props(os.path.join(os.path.dirname(__file__), "./templates/build.gradle.template.application"), module_props_for_replace))
for line in generated_lines:
print line
def migrate_main_module_dir():
global _global_module_property_dict
_global_module_property_dict = {}
travesal_project_properties_from_dir(_global_main_module_folder_path, _global_module_property_dict)
main_module_setting_gradle_path = os.path.join(_global_main_module_folder_path, "settings.gradle")
main_module_setting_gradle_file = open(main_module_setting_gradle_path, "w")
main_module_setting_gradle_file.write("rootProject.projectDir = file('.')\n")
main_module_setting_gradle_file.write("\n")
for module_path in _global_module_property_dict.keys():
# write settings.gradle
module_name = _global_module_property_dict[module_path]["module_name"]
main_module_setting_gradle_file.write("include ':%s'\n" % module_name)
main_module_setting_gradle_file.write("project(':%s').projectDir = file('%s')\n" % (module_name, os.path.relpath(module_path, _global_main_module_folder_path)))
main_module_setting_gradle_file.write("\n")
# write build.gradle
generate_module_build_gradle_file(module_path, _global_module_property_dict[module_path])
main_module_setting_gradle_file.close()
def main():
global _global_main_module_folder_path
global _global_created_files
_global_created_files = []
if len(sys.argv) < 2:
print_usage()
return
_global_main_module_folder_path = sys.argv[1]
if not os.path.exists(_global_main_module_folder_path):
print_usage()
return
migrate_main_module_dir()
if __name__ == '__main__':
main()
|
#!/usr/bin/python3
from flask import Flask, url_for
from flask import Response, make_response
from flask import request
app = Flask(__name__)
@app.route('/')
def v_index():
rsp = make_response('go <a href = "%s">page2</a>' % url_for('v_page2'))
rsp.set_cookie('user','JJJJohnny')
return rsp
#
@app.route('/page2')
def v_page2():
user = request.cookies['user']
return ('you are %s' % user)
if __name__ == "__main__":
app.debug = True
app.run(host="192.168.0.73",port=12306)
|
from topic_modelling import *
# This file is used to create a beta matrix for LDA
Corpus(transf=transformations, transf_parameters={'tfidf': {'load': False, 'bzip2': True},
'lsi': {'load': False, 'topics': n_topics},
'lda': {'load': False, 'topics': n_topics, 'cpu_cores': n_cpu_cores},
'hdp': {'load': False}}) |
#!/usr/bin/env python
# -*-coding:utf-8-*-
'''
通用方法工具类
@author: 'wanggongzheng'
'''
import sys
import datetime
import time
import config
import math
def is_null_str(src_str):
"""判断字符串是否为缺省值"""
null_str_list = [r'NULL', r'NONE', r'\N']
if src_str.upper() in null_str_list :
return True
return False
def generate_sql(table_name, columns, conditions):
'''
构造SQL查询语句
:param table_name:
:param columns:
:param conditions:
:return:
'''
sql_list = []
sql_list.append(' SELECT ')
sql_list.append(', '.join(columns))
sql_list.append(' FROM ')
sql_list.append(table_name + ' ')
condition_str = conditions.strip(" ")
if condition_str != "" :
sql_list.append(" WHERE " + condition_str)
return ' '.join(sql_list)
def get_dataframe(hive_context, table_name, src_features, conditions):
"""执行spark sql获取dataframe"""
sql_str = generate_sql(table_name, src_features, conditions)
log_info(sql_str)
data_frame = hive_context.sql(sql_str)
return data_frame
def map_row_with_key(row, key_names, v_names):
"""将row映射为(key, value)格式，当key个数为1时，不用元祖包装"""
key_values = [str(row[a]) for a in key_names]
key_tuple_values = tuple(key_values)
if(len(key_values) == 1):
key_tuple_values = (key_values[0])
feature_values = [row[a] for a in v_names]
feature_str = tuple_to_strs(feature_values)
return (key_tuple_values, feature_str)
def fill_default_None_strs(column_num, default_str=config.str_for_None, delimiter=config.delimiter):
"""产生column_num列用分隔符以及缺省值的表示的缺省特征，用于join时缺失值填充"""
res_element_list = [default_str] * column_num
return delimiter.join(res_element_list)
def stardard_None_str(src, default_str=config.str_for_None):
"""将NULL 或None等格式缺失统一转化为统一的缺省字符"""
s_str = str(src)
res_str = s_str.strip(" ")
res_str = res_str.lower()
if res_str == "null" or res_str == "none" :
s_str = default_str
return s_str
def tuple_to_strs(element, delimiter=config.delimiter):
"""将tuple或list转为分隔符分隔的字符串"""
if type(element) == str or type(element) == unicode:
return str(element)
else:
element_str_list = map(stardard_None_str, element)
return delimiter.join(element_str_list)
def left_join_fill_none(ele, right_num, delimiter=config.delimiter,
default_str=config.str_for_None):
"""left join产出的value聚合为字符串值，如果右边缺失，则根据右边数据源的数据列数补充\N"""
right_str = ""
if ele[1][1] == None:
right_str = fill_default_None_strs(right_num, default_str, delimiter)
else :
right_str = tuple_to_strs(ele[1][1], delimiter)
left_str = tuple_to_strs(ele[1][0], delimiter)
return (ele[0], left_str + delimiter + right_str)
def left_join_fill_none_strs(ele, right_num, delimiter=config.delimiter,
default_str=config.str_for_None):
"""left join产出的key和value聚合为字符串值，如果右边缺失，则根据右边数据源的数据列数补充\N"""
key_str = tuple_to_strs(ele[0])
(key, value_str) = left_join_fill_none(ele, right_num, delimiter, default_st)
return key_str + delimiter + value_str
def date_to_ymd_tuple(job_date):
"""获取日期的年月份并以元组方式返回"""
year = datetime.datetime.strftime(job_date, "%Y")
month = datetime.datetime.strftime(job_date, "%m")
day = datetime.datetime.strftime(job_date, "%d")
return (year, month, day)
def date_to_ymd_str(job_date):
"""获取日期的YYYYmmdd 20160401格式的字符串"""
year = datetime.datetime.strftime(job_date, "%Y")
month = datetime.datetime.strftime(job_date, "%m")
day = datetime.datetime.strftime(job_date, "%d")
ymd = year + month + day
return ymd
def get_delta_date(job_date, delta):
"""获取job_date相隔delta的日期"""
deltaTime = datetime.timedelta(days=delta)
target_date = job_date + deltaTime
return target_date
def get_near_days(job_date, from_delta, to_delta):
"""获取job_date相隔from_delta到相隔to_delta日期列表，左闭右开"""
near_days =[]
for i in range(from_delta, to_delta):
c_date = job_date + datetime.timedelta(days=i)
c_date_str = datetime.datetime.strftime(c_date, "%Y%m%d")
near_days.append(c_date_str)
return near_days
def get_day_delta(day1, day2, day_format ="%Y-%m-%d"):
"""获取两个日期（字符串形式，例如2016-12-01)之间的间隔天数"""
day1_date = datetime.datetime.strptime(day1,day_format)
day2_date = datetime.datetime.strptime(day2,day_format)
return (day2_date - day1_date).days
def log_info(msg):
"""简单的日志包装，提供时间记录，如果复杂日志格式需求的话，可以自行替换"""
msg = str(msg)
print '[' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time())) + ']:::' + msg
def log_fatal(msg):
"""输出错误级别日志,提供特定格式、醒目的前缀，便于后续查找错误信息 """
msg_str = str(msg)
log_info(config.error_prefix + msg_str)
def log_warn(msg):
"""输出警告级别日志，需关注，但不影响数据的正确性 """
msg_str = str(msg)
log_info(config.warn_prefix + msg_str)
def save_rdd_to_hdfs(sc, res_rdd, job_date, hdfs_path_prefix, res_name = "", file_count= config.output_hdfs_file_cnt):
"""将rdd按照时间分区的路径存储到hdfs上"""
(year, month, day) = date_to_ymd_tuple(job_date)
path = hdfs_path_prefix
path += "/" + year + "/" + month + "/" + day
log_info(res_name + " output path=" + path)
res_rdd.coalesce(file_count) \
.saveAsTextFile(path)
def rad(d):
return (math.pi * d ) / 180.0
def sphereDistance(lat1, lng1, lat2, lng2):
"""输入为经纬度，计算两个点之间球面距离，单位为米"""
EARTH_RADIUS = 6378.137
radLat1 = rad(lat1)
radLat2 = rad(lat2)
a = radLat1 - radLat2
b = rad(lng1) - rad(lng2)
s = 2 * math.asin(math.sqrt(math.pow(math.sin(a / 2), 2)
+ math.cos(radLat1) * math.cos(radLat2) * math.pow(math.sin(b / 2), 2)))
s = round(s * EARTH_RADIUS * 1000)
return abs(s)
def map_to_libsvm(label, res_feas):
"""将特征数组以及label生成libsvm格式，label为label值，res_fea为特征数组"""
res_str = str(label)
for (i,value) in enumerate(res_feas):
value_str = str(value)
if value_str == str(config.str_for_None):
value_str = config.missing_value_libsvm
res_str += " " + str(i+1) + ":" + str(value_str)
return res_str
def map_arr_to_libsvm(label_index, label_feas_arr):
"""包含了label的特征数组生成为libsvm格式，label_index为label在数组的位置，label_feas_arr为label + 特征的数组"""
label = label_feas_arr[label_index]
res_fea = label_feas_arr[0:label_index] + label_feas_arr[label_index+1:len(label_feas_arr)]
return map_to_libsvm(label, res_fea)
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Feb 7 18:41:11 2017
@author: brendontucker
"""
matrix = [[0, 1, 1, 2],
[0, 5, 0, 0],
[2, 0, 3, 3]]
rowCount = len(matrix)
total = 0
current = 0
row = 0
col = 0
columnCount = len(matrix[0])
'''
while row < rowCount :
col = 0
while col < colCount :
if matrix[row][col] == 0:
col += 1
'''
while col < columnCount :
row = 0
while row < rowCount :
if matrix[row][col] == 0:
break
else:
current = matrix[row][col]
total += current
row += 1
#after while row loop terminates
col += 1
|
from std_msgs import String
from uros import NodeHandle
import time
def cb(msg):
print(msg.data)
msgp = String()
msgp.data = "ItsMeLuigi"
node = NodeHandle(2, 57600)
node.subscribe("chatter", String, cb)
while True:
node.publish("groop", msgp)
time.sleep(1)
|
class EventHandler:
def is_event_as_expected(self, event):
pass
def build_message_string(self, event):
pass
|
from copy import deepcopy
class Solution:
def minPathCost(self, g, mc):
m,n,dp = len(g), len(g[0]),deepcopy(g)
for i in range(1, m):
for j in range(n):
crow = float("inf")
for k in range(n): crow = min(crow, dp[i-1][k] + mc[g[i-1][k]][j])
dp[i][j] += crow
return min(dp[m-1])
|
import json
import unittest
from tests.helper_tests import InitTests
class UserTests(unittest.TestCase):
def setUp(self):
InitTests.testSetUp(self)
def tearDown(self):
InitTests.testTearDown(self)
def test_can_create_user(self):
self.user = {"email": "juma@ymail.com", "username": "Juma", "password": "pass123"}
resp = self.client.post(self.BASE_URL + 'register', data=json.dumps(
self.user), content_type='application/json')
self.assertEqual(resp.status_code, 201,
msg="Successfully registered")
def test_can_create_user_fail_username_exists(self):
self.user = {"email": "mbiy@gmail", "username": "Mercy Mbiya", 'password': 'pass123'}
resp = self.client.post(self.BASE_URL + 'register', data=json.dumps(
self.user), content_type='application/json')
self.assertEqual(resp.status_code, 409,
msg="Failed, Username or email already exists, Please sign In")
def test_can_login_user_pass(self):
self.successuser = {"username": "Mercy Mbiya", "password": "pass123", "email": "mbiya@gmail.com"}
responce = self.client.post(self.BASE_URL + 'login', data=json.dumps(
self.successuser), content_type='application/json')
self.assertEqual(responce.status_code, 200,
msg="Successfully logged In")
def test_can_login_user_fails(self):
self.successuser = {"username": "Mercy Mbiya", "password": "Badpass123", "email": "mbiya@gmail.com"}
respo = self.client.post(self.BASE_URL + 'login', data=json.dumps(
self.successuser), content_type='application/json')
self.assertTrue(respo.status_code, 401)
def test_can_logout_user(self):
resp = self.client.post(self.BASE_URL + 'logout', content_type='application/json', headers={'access-token': self.tokenuser})
self.assertEqual(resp.status_code, 200,
msg="Successful you are logged out")
def test_can_logout_user_fail(self):
resp = self.client.post(self.BASE_URL + 'logout', content_type='application/json')
self.assertEqual(resp.status_code, 200,
msg="user unknown")
def test_can_reset_password(self):
self.resetdata = {"username": "Mercy Mbiya", 'password': 'pass123', 'new_password': 'pass456',
'confirm_new_password': 'pass456'}
resp = self.client.post(self.BASE_URL + 'reset', data=json.dumps(
self.resetdata), content_type='application/json')
self.assertEqual(resp.status_code, 200,
msg="Reset success")
def test_can_reset_password_fail(self):
self.resetdata = {"username": "Mercy Mbiya", 'password': 'pass123', 'new_password': 'canadian123',
'confirm_new_password': 'can123'}
resp = self.client.post(self.BASE_URL + 'reset', data=json.dumps(
self.resetdata), content_type='application/json', headers={'access-token': self.tokenuser})
self.assertEqual(resp.status_code, 200,
msg="New Passwords do not match")
def test_can_reset_fields_empty(self):
self.resetdata = {'username': 'Miguna'}
resp = self.client.post(self.BASE_URL + 'reset', data=json.dumps(
self.resetdata), content_type='application/json', headers={'access-token': self.tokenuser})
self.assertEqual(resp.status_code, 400,
msg="Make sure to fill all required fields")
def test_book_not_found(self):
self.book_data = "11"
resp = self.client.post('/api/v1/users/books/' + self.book_data,
content_type='application/json',
headers={'access-token': self.tokenuser})
self.assertEqual(resp.status_code, 404, msg='Book not found')
def test_user_can_borrow_a_book_not_logged_in(self):
data = {"userid": 2}
self.book_data = "4"
# send the data
resp = self.client.post('/api/v1/users/books/' + self.book_data,
content_type='application/json', headers={'Authorization': 'Bearer '})
self.assertEqual(resp.status_code, 401, msg='Token is missing, login to get token')
def test_book_not_exist(self):
self.book_data = "18"
# send the data
resp = self.client.post('/api/v1/users/books/' + self.book_data,
content_type='application/json', headers={'access-token': self.tokenuser})
self.assertEqual(resp.status_code, 404, msg='Item not found')
if __name__ == '__main__':
unittest.main()
|
from RetimingProject_Main import *
from memory_profiler import memory_usage
import sys
if(len(sys.argv)<=2):
print("Error. You must specify the value to iterate. E.g: python3 timeProfiler.py correlator/generator 10")
else:
opt1x = []
opt1y = []
opt2x = []
opt2y = []
for i in range(int(sys.argv[2])):
x = (i+1)*10
if (sys.argv[1] == "generator"):
g = graphGenerator(x)
elif (sys.argv[1] == "correlator") :
g = graphCorrelator(x)
else:
print("Error. You should test the profiler with either graph generator or correlator.")
print("Example: python3 profiler.py generator/correlator 10")
break
#OPT1
start = time.time()
OPT1(g)
end = time.time()
y = end-start
opt1x.append(x)
opt1y.append(y)
#OPT2
start = time.time()
OPT2(g)
end = time.time()
y = end-start
opt2x.append(x)
opt2y.append(y)
showTimeGraph(opt1x, opt1y, opt2x, opt2y)
|
import string
import no_bytecode
def pw_check(password):
if len(password) >= 24:
ABC = dict.fromkeys(string.uppercase, True)
abc = dict.fromkeys(string.lowercase, True)
nums = dict.fromkeys(string.digits, True)
sym = dict.fromkeys(string.punctuation, True)
ABC_flag = abc_flag = nums_flag = sym_flag = True
for char in password:
if ABC_flag and char in ABC:
ABC_flag = False
elif abc_flag and char in abc:
abc_flag = False
elif nums_flag and char in nums:
nums_flag = False
elif sym_flag and char in sym:
sym_flag = False
if not any((ABC_flag, abc_flag, nums_flag, sym_flag)):
print "Valid password"
return True
else:
print "Invalid password"
return False
else:
return False
|
# process_memory_scanner.py by Cadaver
# this is written for Python 2.7 and tested on windows 7 64bit with 32bit processes.
# it can scan an entire process for a integer value in under half a second.
# it can also scan for any ctype within python ctypes or ctypes.wintypes modules \
# simply by creating an instance of the type and passing it as the target to the Scanner class.
# license: public domain
import gc
from ctypes import *
from time import time, sleep
from ctypes.wintypes import *
from threading import Thread
from struct import calcsize, pack, unpack, Struct
from win32gui import PyGetString, PySetString
from win32process import GetProcessMemoryInfo
from win32api import GetCurrentProcessId, GetCurrentProcess, CloseHandle
from win32con import MEM_FREE, PROCESS_VM_READ, PROCESS_VM_WRITE, PROCESS_QUERY_INFORMATION
from win32con import PAGE_READWRITE, PAGE_WRITECOPY, PAGE_EXECUTE_READWRITE, PAGE_EXECUTE_WRITECOPY
from win32con import PAGE_EXECUTE_READ, PAGE_READONLY, PROCESS_VM_OPERATION, PROCESS_ALL_ACCESS
DEBUG_QUERY = False # print VirtualQueryEx info.
DEBUG_SLICE = False # print Python string slice detailed used for comparison.
DEBUG_EXCEPTIONS = False # print some ignored exceptions that might occure.
DEBUG_ALIGNMENT = False # print alignment info.
DEBUG_COMPARE = False # print compare info
ASSUME_ALIGNMENT = True # assume any non string type could be byte aligned.
ACCESS = PROCESS_VM_READ | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_QUERY_INFORMATION
WRITABLE = PAGE_READWRITE | PAGE_WRITECOPY |PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY
READABLE = PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_READONLY | PAGE_READWRITE
MEMORY_STATES = {0x1000: "MEM_COMMIT", 0x10000: "MEM_FREE", 0x2000: "MEM_RESERVE"}
MEMORY_PROTECTIONS = {0x10: "PAGE_EXECUTE", 0x20: "PAGE_EXECUTE_READ", 0x40: "PAGEEXECUTE_READWRITE",
0x80: "PAGE_EXECUTE_WRITECOPY", 0x01: "PAGE_NOACCESS", 0x04: "PAGE_READWRITE", 0x08: "PAGE_WRITECOPY"}
MEMORY_TYPES = {0x1000000: "MEM_IMAGE", 0x40000: "MEM_MAPPED", 0x20000: "MEM_PRIVATE"}
# debug function to time an operation.
def timeit (func):
import time
t1 = time.time ()
ret = func()
print "Time taken:", time.time () - t1
return ret
class MEMORY_BASIC_INFORMATION (Structure):
_fields_ = [
("BaseAddress", c_void_p),
("AllocationBase", c_void_p),
("AllocationProtect", DWORD),
("RegionSize", UINT),
("State", DWORD),
("Protect", DWORD),
("Type", DWORD)
]
class PyMEMORY_BASIC_INFORMATION:
def __init__ (self, MBI):
self.MBI = MBI
self.set_attributes ()
def set_attributes (self):
self.BaseAddress = self.MBI.BaseAddress
self.AllocationBase = self.MBI.AllocationBase
self.AllocationProtect = MEMORY_PROTECTIONS.get (self.MBI.AllocationProtect, self.MBI.AllocationProtect)
self.RegionSize = self.MBI.RegionSize
self.State = MEMORY_STATES.get (self.MBI.State, self.MBI.State)
#self.Protect = self.MBI.Protect # uncomment this and comment next line if you want to do a bitwise check on Protect.
self.Protect = MEMORY_PROTECTIONS.get (self.MBI.Protect, self.MBI.Protect)
self.Type = MEMORY_TYPES.get (self.MBI.Type, self.MBI.Type)
class SYSTEM_INFO(Structure):
_fields_ = [("wProcessorArchitecture", WORD),
("wReserved", WORD),
("dwPageSize", DWORD),
("lpMinimumApplicationAddress", DWORD),
("lpMaximumApplicationAddress", DWORD),
("dwActiveProcessorMask", DWORD),
("dwNumberOfProcessors", DWORD),
("dwProcessorType", DWORD),
("dwAllocationGranularity", DWORD),
("wProcessorLevel", WORD),
("wProcessorRevision", WORD)]
class TARGET:
"""Given a ctype (initialized or not) this coordinates all the information needed to read, write and compare."""
def __init__ (self, ctype):
self.alignment = 1
self.ctype = ctype
# size of target data
self.size = sizeof (ctype)
self.type = ctype._type_
# get the format type needed for struct.unpack/pack.
while hasattr (self.type, "_type_"):
self.type = self.type._type_
# string_buffers and char arrays have _type_ 'c'
# but that makes it slightly slower to unpack
# so swap is for 's'.
if self.type == "c":
self.type = "s"
# calculate byte alignment. this speeds up scanning substantially
# because we can read and compare every alignment bytes
# instead of every single byte.
# although if we are scanning for a string the alignment is defaulted to 1 \
# (im not sure if this is correct).
elif ASSUME_ALIGNMENT:
# calc alignment
divider = 1
for i in xrange (4):
divider *= 2
if not self.size % divider:
self.alignment = divider
# size of target ctype.
self.type_size = calcsize (self.type)
# length of target / array length.
self.length = self.size / self.type_size
self.value = getattr (ctype, "raw", ctype.value)
# the format string used for struct.pack/unpack.
self.format = str (self.length) + self.type
# efficient packer / unpacker for our own format.
self.packer = Struct (self.format)
def get_packed (self):
"""Gets the byte representation of the ctype value for use with WriteProcessMemory."""
return self.packer.pack (self.value)
def __str__ (self):
return str (self.ctype) [:10] + "..." + " <" + str (self.value)[:10]+ "..." + ">"
class LOCK:
"""Locks a value to process memory by writing to it in a loop."""
def __init__ (self, process_handle, address, target, interval=0.001):
self.process_handle = process_handle
self.address = address
self.target = target
self.interval = interval
self.lock_ = True
def thread_lock (self):
self.lock_ = True
process_handle = self.process_handle
address = self.address
target = self.target
interval = self.interval
while self.lock_:
write_target (process_handle, address, target)
sleep (interval)
def stop (self):
self.lock_ = False
def start (self):
self.lock_ = True
Thread (None, self.thread_lock).start ()
def __del__ (self):
self.stop ()
def OpenProcess (pid=GetCurrentProcessId()):
phandle = windll.kernel32.OpenProcess (\
ACCESS, #PROCESS_ALL_ACCESS, # alternative access right for debugging.
False,
pid )
assert phandle, "Failed to open process!\n%s" % WinError (GetLastError ()) [1]
return phandle
def VirtualQueryEx (process_handle, address):
MBI = MEMORY_BASIC_INFORMATION ()
MBI_pointer = byref (MBI)
size = sizeof (MBI)
success = windll.kernel32.VirtualQueryEx (
process_handle,
address,
MBI_pointer,
size )
assert success, "VirtualQueryEx Failed with success == %s.\n%s" % (success, WinError (GetLastError ()) [1])
assert success == size, "VirtualQueryEx Failed because not all data was written."
return PyMEMORY_BASIC_INFORMATION (MBI)
def VirtualProtectEx (process_handle, address, size, new_protection):
old_protection = DWORD ()
old_protection_pointer = byref (old_protection)
success = windll.kernel32.VirtualProtectEx (
process_handle,
address,
size,
new_protection,
old_protection_pointer )
assert success, "VirtualProtectEx Failed with success == %s.\n%s" % (success, WinError (GetLastError ()) [1])
return old_protection.value
def ReadMemory (process_handle, address, size):
cbuffer = c_buffer (size)
success = windll.kernel32.ReadProcessMemory (
process_handle,
address,
cbuffer,
size,
0 )
assert success, "ReadMemory Failed with success == %s and address == %s and size == %s.\n%s" % (success, address, size, WinError (GetLastError()) [1])
return cbuffer.raw
def WriteMemory (process_handle, address, data):
"""Writes string data to process and returns success."""
size = len (data)
success = windll.kernel32.WriteProcessMemory (\
process_handle,
address,
data,
size,
0 )
assert success, "Failed to write process memory!\n%s" % WinError (GetLastError()) [1]
return success
def write_target (process_handle, address, target):
# target can be a ctype initialized with value.
"""Writes TARGET instance to address."""
if not isinstance (target, TARGET):
target = TARGET (target)
return WriteMemory (process_handle, address, target.get_packed())
def read_target (process_handle, address, target):
# target can be a ctype initialized with value.
"""Reads TARGET instance from address and returns the unpacked python equivalent."""
if not isinstance (target, TARGET):
target = TARGET (target)
bytes_ = ReadMemory (process_handle, address, target.size)
return target.packer.unpack (bytes_) [0]
def scan_page (process_handle, page_address, target):
# target must be TARGET instance. eg TARGET (c_int (123)).
"""Scans the entire page for TARGET instance and returns the next page address and found addresses."""
information = VirtualQueryEx (process_handle, page_address)
base_address = information.BaseAddress
region_size = information.RegionSize
next_region = base_address + region_size
size = target.size
format_ = target.format
target_value = target.value
step = target.alignment
unpacker = target.packer.unpack
found = []
# Filter out any pages that are not readable by returning the next_region address
# and an empty list to represent no addresses found.
if information.Type != "MEM_PRIVATE" or \
region_size < size or \
information.State != "MEM_COMMIT" or \
information.Protect not in ["PAGE_EXECUTE_READ", "PAGEEXECUTE_READWRITE", "PAGE_READWRITE"]:
return next_region, []
if DEBUG_QUERY:
print vars (information)
# read the whole page into buffer.
page_bytes = ReadMemory (process_handle, base_address, region_size)
# iterate over the page buffer bytes in steps of alignment
# and unpack those bytes into the format described by
# TARGET instance, then compare with TARGET.
for i in xrange (0, (region_size - size), step):
partial = page_bytes [i:i + size]
if unpacker (partial) [0] == target_value:
found.append (base_address + i)
if DEBUG_SLICE:
print "Found at address: %s i: %s Partial: %s Len_Partial: %s Alignment: %s." \
% (base_address+i, i, partial, len(partial), step)
if DEBUG_COMPARE:
print "Unpacked: %s Partial: %s" % (repr(unpacker (partial)[0]), repr(target_value))
del page_bytes # free the buffer
return next_region, found
def scan_addresses (process_handle, addresses, target):
"""Scans addresses and returns a dictionary of {address: value}."""
values = {}
for address in addresses:
try:
value = read_target (process_handle, address, target)
except Exception, error:
# the process may of freed the page while we are scanning.
if DEBUG_EXCEPTIONS:
raise
continue
values [address] = value
return values
def scan_addresses_for_target (process_handle, addresses, target):
"""Scan addresses and returns a list of those addresses that match the target value."""
target_value = target.value
found = list ()
values = scan_addresses (process_handle, addresses, target)
for address, value in values.items ():
if value == target_value:
found.append (address)
return found
def scan_addresses_for_change (process_handle, addresses, target):
"""scan addresses and returns a list of those addresses that don't match the target value."""
target_value = target.value
found = list ()
values = scan_addresses (process_handle, addresses, target)
for address, value in values.items ():
if value != target_value:
found.append (address)
return found
def scan_process (process_handle, target):
"""scans a processes pages for the target value."""
if not isinstance (target, TARGET):
target = TARGET (target)
if DEBUG_ALIGNMENT:
print "Target: %s Size: %s Alignment: %s." % (target.ctype, target.size, target.alignment)
si = SYSTEM_INFO ()
psi = byref (si)
windll.kernel32.GetSystemInfo (psi)
# get the first address of the first page to scan so we know where to start scanning
base_address = si.lpMinimumApplicationAddress
# get the last address to scan so we know when to stop scanning.
max_address = si.lpMaximumApplicationAddress
found = list ()
page_address = base_address
while page_address < max_address:
next_page, f = scan_page (process_handle, page_address, target)
found.extend (f)
page_address = next_page
if len (found) >= 60000000:
print "[Warning] Scan ended early because too many addresses were found to hold the target data."
break
gc.collect ()
return found
class Scanner:
def __init__ (self, pid, ctype=None):
self.pid = pid
self.process_handle = OpenProcess (pid)
self.target = None
self.found = list ()
self.locks = list ()
if ctype:
self.set_target (ctype)
def set_target (self, ctype):
self.target = TARGET (ctype)
def scan_process(self):
self.found = scan_process (self.process_handle, self.target)
print len (self.found), "Addresses with value %s found." % (self.target)
def scan_for_change (self):
self.found = scan_addresses_for_change (self.process_handle, self.found, self.target)
print len (self.found), "Addresses with NOT value %s found." % (self.target)
def scan_for_new_target (self, ctype):
target = TARGET (ctype)
self.found = scan_addresses_for_target (self.process_handle, self.found, target)
print len (self.found), "Addresses with new value %s found." % (self.target)
def scan_addresses (self, addresses=None):
if not addresses:
addresses = self.found
return scan_addresses (self.process_handle, addresses, self.target)
def write_target (self, address, target):
return write_target (self.process_handle, address, target)
def read_target (self, address, target):
return read_target (self.process_handle, address, target)
def lock_target (self, address, target):
if not isinstance (target, TARGET):
target = TARGET (target)
lock = LOCK (self.process_handle, address, target)
lock.start ()
self.locks.append (lock)
def stop_locks (self):
for lock in self.locks:
lock.stop ()
self.locks = list ()
def __del__ (self):
del self.found
if self.process_handle:
CloseHandle (self.process_handle)
def test ():
global PID, p, s, a, na
PID = GetCurrentProcessId ()
#p = OpenProcess ()
s = Scanner (PID, create_string_buffer ("teststringthing"))
# s = Scanner (PID, c_int (123))
print "Scanning process."
timeit (s.scan_process)
a = s.found [0]
print "Locking found[0]."
s.lock_target (a, create_string_buffer ("new str"))
print "Writing target."
s.write_target (a, create_string_buffer ("new str 2"))
print "Scanning for changes."
s.scan_for_change ()
print "Scanning for new target."
s.scan_for_new_target (c_int (1))
print "Scanning addresses."
s.found = [a]
na=s.scan_addresses ()
print "Reading target."
r = s.read_target (a, c_int)
print "Writing target."
s.write_target (a, create_string_buffer ("test"))
s.write_target (a, c_double (88.8))
s.write_target (a, c_int (123))
s.write_target (a, c_float (1.2))
s.stop_locks ()
Scanner.__doc__ = """
class Scanner:
This is the main scanner class that attempts to provide a tidy API for scanning a remote process for values.
def __init__ (self, pid, ctype=None):
This is the initializer that takes the process iD and any ctype from the ctype module or wintype
from the wintype module as the type and value we want to scan for
eg c_int (1) - if we want to search for a integer of value 1, or
create_string_buffer ("test") - if we want to search for a string of value 'test'.
def set_target (self, ctype):
Sets the ctype (with value) of the data we want to search for.
def scan_process(self):
Scans the process for target and saves the found addresses in self.found.
def scan_for_change (self):
Scans the addresses in self.found for any value that isnt the target value
and saves these new addresses in self.found.
def scan_for_new_target (self, ctype):
Scans the addresses in self.found for a new value and returns the ones that match.
def scan_addresses (self, addresses=None):
Scans the addresses and returns a dictionary of {address, value}.
def write_target (self, address, target):
Writes the data described by target to the address.
def read_target (self, address, target):
Reads the data described by target from address.
def lock_target (self, address, target):
Locks address to target value.
def stop_locks (self):
Terminates all current locks.
"""
if __name__ == "__main__":
print Scanner.__doc__
raw_input ("[paused]")
|
from palindrome import palindrome as p
class Test_time:
def test_p_correct(self):
assert p("racecar") == "racecar is a palindrome"
assert p("snickers") == "snickers is not a palindrome"
assert p("blalb") == "blalb is a palindrome"
def test_p_type(self):
assert p("~~.~~") == "~~.~~ is a palindrome"
assert p("90091") == "90091 is not a palindrome"
assert p("123") == "123 is not a palindrome"
def test_p_null(self):
assert p("") == " is a palindrome"
assert p(" ") == " is a palindrome"
assert p(" ") == " is not a palindrome"
|
from tools.db_oprt_base import DataBaseOprt
import mysql.connector
class DataBaseOprtMySQL(DataBaseOprt):
class DataBaseParams:
class DB5:
host = '0.0.0.5'
port = '3306'
user = 'steff'
pwd = 'password'
class DB11:
host = '0.0.0.11'
port = '3306'
user = 'steff'
pwd = 'password'
class DB21:
host = '0.0.0.21'
port = '3306'
user = 'steff'
pwd = 'password'
class DB29:
host = '0.0.0.29'
port = '3306'
user = 'steff'
pwd = 'password'
class DB32:
host = '0.0.0.32'
port = '3306'
user = 'steff'
pwd = 'password'
class DB42:
host = '0.0.0.42'
port = '3306'
user = 'steff'
pwd = 'password'
class SQL:
sql_get_com = "select commission_json from tradingconfigdb.t_simple_general_commission_template " \
"where `name`='测试标准模板'"
sql_get_fees = "SELECT fee_rate from tradingconfigdb.t_simple_fixed_fee " \
"where fee_type = '{0}' " \
"and trade_type = '{1}' " \
"and security_type = '{2}' " \
"and market_id = '{3}'"
class OperateDB:
def __init__(self, conn_params_obj, db='testdb'):
self.conn = mysql.connector.connect(
host=conn_params_obj.host,
port=conn_params_obj.port,
user=conn_params_obj.user,
passwd=conn_params_obj.pwd,
db=db,
charset='utf8')
self.cur = self.conn.cursor()
def execute_query(self, sql):
try:
self.cur.execute(sql)
result = self.cur.fetchall()
print(result)
# a = ("{0}".format(result))
# b = re.findall(r"\d+.?\d*", a)
# return b
except mysql.connector.Error as e:
print('query error!{}'.format(e))
finally:
print('end')
self.close()
def close(self):
self.cur.close()
self.conn.close()
|
import os
f = 30
gitpull = 1
#[37,32,27,22]
qps = [20,32,43,55]
OPT = 0 # optimizacoes ligadas = 1
gprof = 1
threads = 5 # numero de processos em parelelo
#gitpath = "git_repo/pesquisa_av1"
gitpath = "pesquisa_ucpel/pesquisa_av1"
gitscript = "git_upl"
#shpath = "git_repo/common_research/codes/run-sh/aom"
shpath = "pesquisa_ucpel/pesquisa_av1/common_research/codes/run-sh/aom"
filename = "run_av1.sh"
#yuvs = ["RaceHorses_832x480_30.yuv","BasketballDrill_832x480_50.yuv","BQMall_832x480_60.yuv","PartyScene_832x480_50.yuv"]
yuvs = os.listdir("~/Videos/av1_sets")
#["BlowingBubbles_416x240_50.yuv","BQSquare_416x240_60.yuv","BasketballPass_416x240_50.yuv","RaceHorses_416x240_30.yuv"] #ClasseD
#["RaceHorses_832x480_30.yuv","BasketballDrill_832x480_50.yuv","BQMall_832x480_60.yuv","PartyScene_832x480_50.yuv"] #ClasseC
#["FourPeople_1280x720_60.yuv","Johnny_1280x720_60.yuv","SlideEditing_1280x720_30.yuv"] #ClasseE e F
#["Tennis_1920x1080_24.yuv","ParkScene_1920x1080_24.yuv","BasketballDrive_1920x1080_50.yuv","Kimono_1920x1080_24.yuv","BQTerrace_1920x1080_60.yuv","Cactus_1920x1080_50.yuv"] #ClasseB
#["PeopleOnStreet_2560x1600_30_crop.yuv","Traffic_2560x1600_30_crop.yuv"] #ClasseA
yuvpath = "~/Videos/av1_sets"
outpath = "git_repo/pesquisa_av1/output_av1"
binpath = "av1_pesquisa/bin" #partindo da homepath
if OPT == 1:
if gprof == 0:
bina = "aomenc_OPT"
inf = "OPT"
else:
bina = "aomenc_gprof_OPT"
inf = "gprof_OPT"
else:
if gprof == 0:
bina = "aomenc_noOPT"
inf = "noOPT"
else:
bina = "aomenc_gprof_noOPT"
inf = "gprof_noOPT"
file = open("~/%s/%s"%(shpath,filename),"w")
try:
os.system("mkdir ~/%s/"%(outpath))
except:
pass
try:
os.system("mkdir ~/%s/bin"%(outpath))
except:
pass
try:
os.system("mkdir ~/%s/out"%(outpath))
except:
pass
if gprof == 1:
try:
os.system("mkdir ~/%s/gprof"%(outpath))
except:
pass
try:
os.system("mkdir ~/%s/gmon"%(outpath))
except:
pass
for yuv in yuvs:
for qp in qps:
if ".py" in yuv:
continue
nome,dummy = yuv.split(".")
print(yuv)
vid,pix,fr,fl,bit,yf = yuv.split("_")
fl = fl.strip("f")
bit = bit.strip("bit")
w,h = pix.split("x")
info = "%sqp_%sfframes_"%(qp,f) + inf
#qp = map(float,qp) !!--end-usage=q!!--AVALIAR
if gprof == 1:
linha = "%s/%s/%s --fps=%s/1 -w %s -h %s --min-q=%s --max-q=%s --limit=%s --rt -b 8 -o %s/%s/bin/%s_%s.bin %s/%s 2> %s/%s/out/%s_%s.txt"%(homepath,binpath,bina,fr,w,h,qp-3,qp+5,f,homepath,outpath,nome,info,yuvpath,yuv,homepath,outpath,nome,info)
linha2 = "mv %s/%s/gmon.out %s/%s/gmon/gmon_%s_%s.out "%(homepath,shpath,homepath,outpath,nome,info)
linha3 = "gprof %s/%s/%s %s/%s/gmon/gmon_%s_%s.out > %s/%s/gprof/%s_%s.txt"%(homepath,binpath,bina,homepath,outpath,nome,info,homepath,outpath,nome,info)
linha4 = "echo \"%s_%s DONE!\"\n"%(nome,info)
#VERIFICAR SOBRESCRICAO
try:
test = open("%s/%s/out/%s_%s.txt"%(homepath,outpath,nome,info),"r")
tlines = test.readlines()
tline = tlines[-1]
if "Total Time" not in tline:
file.write(linha + " && " + linha2 + " && " + linha3 + " && " + linha4 + "\n")
except:
file.write(linha + " && " + linha2 + " && " + linha3 + " && " + linha4 + "\n")
else:
linha = "{ time %s/%s/%s --fps=%s/1 -w %s -h %s --min-q=%s --max-q=%s --limit=%s --rt -b 8 -o %s/%s/bin/%s_%s.bin %s/%s ; } 2> %s/%s/out/%s_%s.txt"%(homepath,binpath,bina,fr,w,h,qp-3,qp+5,f,homepath,outpath,nome,info,yuvpath,yuv,homepath,outpath,nome,info)
c
linha4 = "echo \"%s_%s DONE!\"\n"%(nome,info)
try:
test = open("%s/%s/out/%s_%s.txt"%(homepath,outpath,nome,info),"r")
tlines = test.readlines()
tline = tlines[-1]
if "Total Time" not in tline:
file.write(linha + " && " + linha4 + "\n")
except:
file.write(linha + " && " + linha4 + "\n")
if gitpull == 1:
linhag = "sh %s/%s/%s.sh\n"%(homepath,gitpath,gitscript)
file.write(linhag)
#if threads == 1:
# if gitpull == 1:
# linhag = "cd %s/%s && sh %s.sh || true"%(homepath,gitpath,gitscript)
# print >> file, linhag
#file.close
'''
i=0
if threads != 1:
file = open("%s/%s/%s"%(homepath,shpath,filename),"r")
lines = file.readlines()
tam = len(lines)
nqp = len(qps)
nconf = len(confs)
for x in range(threads):
try:
os.system("mkdir %s/%s/script%d"%(homepath,shpath,x+1))
except:
pass
file2 = open("%s/%s/script%d/%d_%s"%(homepath,shpath,x+1,x+1,filename),"w")
i = x*nqp
j=0
while i < tam:
line = lines[i]
print >> file2, line
i = i+1
j = j+1
if j == nqp:
j=0
i = (i-nqp)+(nqp*threads)
# if nqp == 4:
# if ((i-1)%4) == 3:
# i = i+threads*(3)
# else:
# j = j+1
# div = tam/threads
# if j == div:
# i = i+threads*div
# j=0
# if gitpull == 1:
# linhag = "cd %s/%s && sh %s.sh || true"%(homepath,gitpath,gitscript)
# print >> file2, linhag
file2.close
file.close
''' |
x = 1
while x<20:
x+=1
if x == 2:
pass
if x == 3:
continue
if x < 100:
print(x)
|
# --------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
# --------------------------------------------------------------------------------------------
# - Generated by tools/entrypoint_compiler.py: do not edit by hand
"""
PixelExtractor
"""
__all__ = ["PixelExtractor"]
from ....entrypoints.transforms_imagepixelextractor import \
transforms_imagepixelextractor
from ....utils.utils import trace
from ...base_pipeline_item import BasePipelineItem, DefaultSignature
class PixelExtractor(BasePipelineItem, DefaultSignature):
"""
Extracts the pixel values from an image.
.. remarks::
``PixelExtractor`` extracts the pixel values from an image. The input
variables
are images of the same size, typically the output of a ``Resizer``
transform. The
output are pixel data in vector form that are typically used as
features for a learner.
:param use_alpha: Specifies whether to use alpha channel. The default
value is ``False``.
:param use_red: Specifies whether to use red channel. The default value
is ``True``.
:param use_green: Specifies whether to use green channel. The default
value is ``True``.
:param use_blue: Specifies whether to use blue channel. The default value
is ``True``.
:param interleave_argb: Whether to separate each channel or
interleave in ARGB order. This might be important, for example, if
you are training
a convolutional neural network, since this would affect the shape of
the kernel, stride etc.
:param convert: Whether to convert to floating point. The default value
is ``False``.
:param offset: Specifies the offset (pre-scale). This requires ``convert
= True``.
The default value is `None`.
:param scale: Specifies the scale factor. This requires ``convert =
True``.
The default value is `None`.
:param params: Additional arguments sent to compute engine.
.. seealso::
:py:class:`Loader <nimbusml.feature_extraction.image.Loader>`,
:py:class:`Resizer <nimbusml.feature_extraction.image.Resizer>`.
.. index:: transform, image
Example:
.. literalinclude:: /../nimbusml/examples/Image.py
:language: python
"""
@trace
def __init__(
self,
use_alpha=False,
use_red=True,
use_green=True,
use_blue=True,
interleave_argb=False,
convert=True,
offset=None,
scale=None,
**params):
BasePipelineItem.__init__(
self, type='transform', **params)
self.use_alpha = use_alpha
self.use_red = use_red
self.use_green = use_green
self.use_blue = use_blue
self.interleave_argb = interleave_argb
self.convert = convert
self.offset = offset
self.scale = scale
@property
def _entrypoint(self):
return transforms_imagepixelextractor
@trace
def _get_node(self, **all_args):
input_columns = self.input
if input_columns is None and 'input' in all_args:
input_columns = all_args['input']
if 'input' in all_args:
all_args.pop('input')
output_columns = self.output
if output_columns is None and 'output' in all_args:
output_columns = all_args['output']
if 'output' in all_args:
all_args.pop('output')
# validate input
if input_columns is None:
raise ValueError(
"'None' input passed when it cannot be none.")
if not isinstance(input_columns, list):
raise ValueError(
"input has to be a list of strings, instead got %s" %
type(input_columns))
# validate output
if output_columns is None:
output_columns = input_columns
if not isinstance(output_columns, list):
raise ValueError(
"output has to be a list of strings, instead got %s" %
type(output_columns))
algo_args = dict(
column=[
dict(
Source=i,
Name=o) for i,
o in zip(
input_columns,
output_columns)] if input_columns else None,
use_alpha=self.use_alpha,
use_red=self.use_red,
use_green=self.use_green,
use_blue=self.use_blue,
interleave_argb=self.interleave_argb,
convert=self.convert,
offset=self.offset,
scale=self.scale)
all_args.update(algo_args)
return self._entrypoint(**all_args)
|
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
from model_rnn import rnn
from dataset import isear
torch.manual_seed(814)
def test():
with torch.no_grad():
correct = 0
total = 0
for i, data in enumerate(valid_loader):
sentences, labels = data[0].to(device), data[1].to(device)
lengths = data[2]
total += len(labels)
ans = model(sentences, lengths).max(1)[1]
correct += sum(ans == labels.max(1)[1]).cpu()
valid_acc = correct / total
print('Validation done, acc: {:.3}'.format(valid_acc))
correct = 0
total = 0
for i, data in enumerate(test_loader):
sentences, labels = data[0].to(device), data[1].to(device)
lengths = data[2]
total += len(labels)
ans = model(sentences, lengths).max(1)[1]
correct += sum(ans == labels.max(1)[1]).cpu()
test_acc = correct / total
print('Test done, acc: {:.3}'.format(test_acc))
return (valid_acc, test_acc)
train_accs, valid_accs, test_accs = [], [], []
def plot(train_acc, valid_acc, test_acc):
train_accs.append(train_acc)
valid_accs.append(valid_acc)
test_accs.append(test_acc)
plt.clf()
x = np.arange(0, len(train_accs))
plt.plot(x, train_accs, label='train_acc')
plt.plot(x, valid_accs, label='valid_acc')
plt.plot(x, test_accs, label='test_acc')
plt.legend()
plt.pause(0.01)
BATCH_SIZE = 50
EPOCH = 100
train_set = isear("train")
valid_set = isear("validation")
test_set = isear("test")
train_loader = torch.utils.data.DataLoader(train_set, shuffle=True,
batch_size=BATCH_SIZE)
valid_loader = torch.utils.data.DataLoader(valid_set, shuffle=True,
batch_size=BATCH_SIZE)
test_loader = torch.utils.data.DataLoader(test_set, shuffle=False,
batch_size=BATCH_SIZE)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('using device: ', device)
model = rnn()
model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adadelta(model.parameters())
for epoch in range(EPOCH):
train_loss = .0
total = 0
correct = 0
for i, data in enumerate(train_loader):
sentences, labels = data[0].to(device), data[1].to(device)
lengths = data[2]
optimizer.zero_grad()
outputs = model(sentences, lengths)
correct += sum(outputs.max(1)[1] == labels.max(1)[1]).cpu()
loss = criterion(outputs, labels.max(1)[1])
train_loss += loss.item()
loss.backward()
optimizer.step()
total += len(labels)
train_acc = correct / total
print('epoch {:3}, batch {:3}, loss {:.3}, acc {:.3}'.format(
epoch + 1, i + 1, train_loss / 100, train_acc))
train_loss = .0
valid_acc, test_acc = test()
plot(train_acc, valid_acc, test_acc)
plt.savefig('rnn.png')
plt.show()
torch.save(model.state_dict(), 'rnn.pth')
torch.save(model, 'rnn-full.pth')
|
# Создайте программу с двумя кнопками растягиваемые по горизонтали,
# прикрепленными к верхней и нижней границам окна.
from tkinter import *
root = Tk()
btn1 = Button(root, text="Button 1")
btn1.pack(side=TOP, fill=X)
btn2 = Button(root, text="Button 2")
btn2.pack(side=BOTTOM, fill=X)
root.mainloop() |
from selenium.common.exceptions import *
from selenium.webdriver.common.by import By
class ElementUtil():
def __init__(self,driver):
self.driver = driver
def getPageTitle(self):
return self.driver.title
def getElement(self,byLocator):
return self.driver.find_element(*byLocator)
def doClear(self,byLocator):
try:
self.getElement(byLocator).clear()
except NoSuchElementException:
print("Element not found with locator",byLocator)
def doClick(self,byLocator):
self.getElement(byLocator).click()
def doSendKeys(self,byLocator,value):
self.getElement(byLocator).send_keys(value)
def isElementVisible(self,byLocator):
return self.getElement(byLocator).is_displayed()
def getElementText(self,byLocator):
return self.getElement(byLocator).text
|
from lib.helpers.parse_name import ParseName
from lib.helpers.parse_credits import ParseCredits
from lib.helpers.parse_field_of_study import ParseFieldOfStudy
from lib.helpers.parse_fos import ParseFos
from lib.helpers.parse_date import ParseDate
from lib.helpers.parse_completion_date import ParseCompletionDate
from lib.helpers.parse_delivery_methods import ParseDeliveryMethod
from lib.helpers.parse_sponsors import ParseSponsors
from lib.helpers.parse_sponsor_id import ParseSponsorId
from lib.helpers.parse_program_name import ParseProgramName
from lib.helpers.parse_qas_number import ParseQasNumber
def parse_all_fields( contents, result):
pn = ParseName(contents)
pn.extract()
pp = ParseProgramName(contents, pn.name)
pp.extract()
ps = ParseSponsors(contents, pp.program_name)
ps.extract()
pd = ParseDate(contents, pn.name, pp.program_name)
pd.extract()
pfos = ParseFos(contents, pp.program_name)
pfos.extract()
pc = ParseCredits(contents, pfos.field_of_study)
pc.extract()
pm = ParseDeliveryMethod(contents, ps.sponsor)
pm.extract()
pi = ParseSponsorId(contents)
pi.extract()
pq = ParseQasNumber(contents)
pq.extract()
result['username'] = {"value": pn.name, "score": ""}
result['program_name'] = {"value": pp.program_name, "score": ""}
#result['field_of_study'] = pf.field_of_study
result['credits'] = {"value": pc.credits, "score": ""}
result['completion_date'] = {"value": pd.date, "score": ""}
#result['completion_date'] = pd.date
result['delivery_format'] = {"value": pm.delivery_method, "score": "" }
result['sponsor_name'] = [{"value": ps.sponsor, "score": "" }]
result['sponsor_number'] = [{"value": pi.sponsor_id, "score": "" }]
#result['sponsor_id'] = pi.ids
result['qas_number'] = {"value": pq.qas_number, "score": ""}
#result['fos'] = pfos.field_of_study
result['field_of_study'] = pc.field_of_study #{"value": pc.field_of_study, "score": ""}
print("RESULT====>", result)
return result
|
import functools
import logging
import os
import shutil
import subprocess
import tempfile
from source.storage.stores.artifact_store.interface import ArtifactStoreInterface
from source.storage.stores.artifact_store.types import DurationMetricArtifact
from source.storage.stores.artifact_store.types.data_ingestion import ClustersUnificationPricingDurationMetricArtifact,\
ClustersUnificationSourceHashArtifact
from source.storage.stores.engine_communication_store.interface import EngineCommunicationStoreInterface
from source.storage.stores.engine_communication_store.uri_based import URIBasedEngineCommunicationStore
from source.task_runner.handler_interface import TaskHandlerInterface
from source.task_runner.tasks.clusters_unification import ClustersUnificationTask
from source.utils.configure_logging import configure_logger
from source.utils.run_repeatedly import RunRepeatedly
WORKSPACE_FOLDERS = [
'/in',
'/meta',
'/out',
'/work_dir',
]
class ClustersUnifier(TaskHandlerInterface):
def __init__(self, artifact_store, engine_communication_store):
"""
@type artifact_store: L{ArtifactStoreInterface}
@type engine_communication_store: L{EngineCommunicationStoreInterface}
"""
self.__engine_communication_store = engine_communication_store
self.__artifact_store = artifact_store
self.__logger = logging.getLogger('endor')
def run_task(self, task):
"""
@type task: L{ClustersUnificationTask}
"""
if task is None:
raise RuntimeError('No task received')
configure_logger(self.__logger, task.get_context())
self.__logger.info('Got task')
self.handle_task(task)
def handle_task(self, task):
"""
@type task: L{ClustersUnificationTask}
"""
self.__clean_workspace()
self.__initialize_workspace()
with ClustersUnificationPricingDurationMetricArtifact(task.customer, task.sphere_id, 'unify_clusters',
self.__artifact_store,
task_ordinal=task.task_ordinal):
self.__process_task(task)
self.__clean_workspace()
@staticmethod
def __initialize_workspace():
for folder in WORKSPACE_FOLDERS:
os.mkdir(folder)
@staticmethod
def __clean_workspace():
for folder in WORKSPACE_FOLDERS:
try:
shutil.rmtree(folder)
except OSError as ex:
if ex.errno != 2:
raise
def __process_task(self, task):
"""
@type task: L{ClustersUnificationTask}
"""
partial_duration_artifact = functools.partial(DurationMetricArtifact, task.customer, task.sphere_id,
'clusters_unification', artifact_store=self.__artifact_store)
with partial_duration_artifact(phase='download'):
for sphere_id in task.input_spheres:
self.__engine_communication_store.download_sphere_blocks(task.customer, sphere_id, '/in',
task.filter_only)
if not self.__engine_communication_store.download_single_params(task.customer,
task.input_spheres[0],
'/meta'):
raise ValueError('Could not download params file.')
self.__logger.debug('Running Phase 8.1')
log_name = 'phase_unifier'
stdout_fd, stdout_path = tempfile.mkstemp('_stdout')
stderr_fd, stderr_path = tempfile.mkstemp('_stderr')
with partial_duration_artifact(phase='8.1'), \
RunRepeatedly(lambda: self.__log_file_size(stdout_path, 'unifier'), 180), \
RunRepeatedly(lambda: self.__log_file_size(stderr_path, 'unifier'), 180):
exit_code = self.__run_phase('8.1,BlockDataAll_new,unified_blocks', stdout_fd, stderr_fd)
self.__logger.debug('Finished Phase 8.1')
os.close(stderr_fd)
os.close(stdout_fd)
self.__engine_communication_store.store_unifier_logs(task.customer, task.sphere_id,
log_name + '_out', stdout_path)
self.__engine_communication_store.store_unifier_logs(task.customer, task.sphere_id,
log_name + '_err', stderr_path)
if exit_code != 0:
raise subprocess.CalledProcessError(exit_code, '8.1,BlockDataAll_new,unified_blocks')
self.__logger.debug('Storing results')
with partial_duration_artifact(phase='upload'):
self.__engine_communication_store.store_unification_results(task.customer, task.sphere_id,
'/out', '/meta/params.txt')
with open('/out/translation.txt') as translation_file:
file_hashes_map = {k: v for k, v in map(lambda x: x.strip().split("="), translation_file.readlines())}
self.__engine_communication_store.store_file_hashes_map(task.customer, task.sphere_id, file_hashes_map)
file_hashes_artifact = ClustersUnificationSourceHashArtifact(task.customer, task.execution_id,
file_hashes_map)
self.__artifact_store.store_artifact(file_hashes_artifact)
self.__logger.debug('Finished storing results')
@staticmethod
def __run_phase(phase_args, stdout_fd, stderr_fd):
phase_process = subprocess.Popen(['/bin/sh', '/home/ubuntu/ENGINE/run_AthenaMain.sh',
'/usr/local/MATLAB/MATLAB_Compiler_Runtime/v83', phase_args],
stdout=stdout_fd, stderr=stderr_fd,
cwd='/home/ubuntu/ENGINE')
return phase_process.wait()
def __log_file_size(self, file_path, logical_name):
file_size = os.path.getsize(file_path)
self.__logger.debug('File {} is sized {}'.format(logical_name, file_size), extra={
'file_path': file_path,
'logical_name': logical_name,
'file_size': file_size
})
@staticmethod
def get_task_type():
return ClustersUnificationTask
@staticmethod
def hash_djb2(inp):
result = 5381
for x in inp:
result = ((result << 5) + result) + ord(x)
return result & 0xFFFFFFFF
def build_prod_clusters_unifier(artifact_store, io_handler):
return ClustersUnifier(artifact_store, URIBasedEngineCommunicationStore(io_handler)) |
import openpyxl
from openpyxl.styles import Alignment
book = openpyxl.load_workbook('xlf/7.xlsx')
sheet = book["Sheet1"]
sheet.sheet_properties.tabColor = "00ff33"
book.save('xlf/7.xlsx')
sheet = book.active
sheet.merge_cells('A1:B2')
cell = sheet.cell(row=1, column=1)
cell.value = 'WOW ITS BIG'
cell.alignment = Alignment(horizontal='left', vertical='center')
book.save('xlf/7.xlsx')
|
# Reset the console
%reset -f
# Import libraries
# Importing requests to extract content from a url
import requests
from bs4 import BeautifulSoup as bs # for web scraping
import matplotlib.pyplot as plt
from wordcloud import WordCloud
# Creating empty review list
poco_reviews = []
for i in range(1,1000):
phone = []
url = "https://www.flipkart.com/poco-f1-xiaomi-steel-blue-128-gb/product-reviews/itmf8hu3fb9bjqz4?pid=MOBF85V7KKANFFZX&page="+str(i)
response = requests.get(url)
# creating soup object to iterate over the extracted content
soup = bs(response.content, "html.parser")
# Extract the content under the specific tag
reviews = soup.find_all("div", attrs={'class':''})
for i in range(len(reviews)):
phone.append(reviews[i].text)
# Adding the reviews of one page to empty list which in future contains all the reviews
poco_reviews = poco_reviews + phone
# Writing reviews in a text file
with open('poco.txt','w', encoding = 'utf8') as output:
output.write(str(poco_reviews))
# Joining all the reviews into single paragraph
poco_rev_string = " ".join(poco_reviews)
# Remove unwanted symbols from text
import re
poco_rev_string = re.sub('[^a-zA-Z]', ' ', poco_rev_string)
# Remove numbers
poco_rev_string = re.sub('[0-9]', ' ', poco_rev_string)
# Convert to lower case
poco_rev_string = poco_rev_string.lower()
# Download the Stopwords
import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords
# split review into words
rev_words = poco_rev_string.split()
rev_words = [word for word in rev_words if not word in set(stopwords.words('english'))]
# Steaming words
from nltk.stem.porter import PorterStemmer
ps = PorterStemmer()
rev_words = [ps.stem(word) for word in rev_words]
# Joining the words to string
rev_words = ' '.join(rev_words)
# Word Cloud can be performed on the string inputs. So combine all the words
wordcloud_poco = WordCloud(background_color='black',
width = 1800, height = 1400).generate(rev_words)
plt.imshow(wordcloud_poco)
# Creating Positive words and Negative Words
import nltk
from nltk.sentiment.vader import SentimentIntensityAnalyzer
sid = SentimentIntensityAnalyzer()
pos_word_list=[]
neu_word_list=[]
neg_word_list=[]
for word in rev_words:
if (sid.polarity_scores(word)['compound']) >= 0.5:
pos_word_list.append(word)
elif (sid.polarity_scores(word)['compound']) <= -0.5:
neg_word_list.append(word)
else:
neu_word_list.append(word)
print('Positive :',pos_word_list)
print('Neutral :',neu_word_list)
print('Negative :',neg_word_list)
# negative word cloud
# Choosing the only words which are present in negwords
poco_neg_rev = " ".join ([word for word in rev_words if word in neg_word_list])
wordcloud_neg_rev = WordCloud(
background_color='black',
width=1800,
height=1400
).generate(poco_neg_rev)
plt.imshow(wordcloud_neg_rev)
# Positive word cloud
# Choosing the only words which are present in positive words
poco_pos_rev = " ".join ([word for word in rev_words if word in pos_word_list])
wordcloud_pos_rev = WordCloud(
background_color='black',
width=1800,
height=1400
).generate(poco_pos_rev)
plt.imshow(wordcloud_pos_rev)
# Unique words
poco_unique_words = list(set(" ".join(poco_reviews).split(" ")))
#from textblob import TextBlob
#import textblob
#from textblob.sentiments import NaiveBayesAnalyzer
#import nltk
#nltk.download('movie_reviews')
#nltk.download('punkt')
#
#sent = TextBlob(rev_words)
#polarity = sent.sentiment.polarity
#subjectivity = sent.sentiment.subjectivity
#
#sent = TextBlob(rev_words, analyzer=NaiveBayesAnalyzer())
#classification = sent.sentiment.classification
#positive = sent.sentiment.p_pos
#negative = sent.sentiment.p_neg
#
#print(polarity, subjectivity, classification, positive, negative)
# Apply sentiment Analysis on each review
for review in poco_reviews:
print(review)
analysis = TextBlob(review)
print(analysis.sentiment,"\n")
|
from lewis.core.statemachine import State
class DefaultState(State):
# Default state
NAME = 'Default'
|
# -*- coding: utf-8 -*-
"""
Created on Mon Aug 8 07:12:56 2016
@author: PM5
Experiment with adding a variable to an existing NetCDF file.
"""
import netCDF4 as nc
import numpy as np
import os
dir0 = os.environ.get('HOME') + '/Desktop/'
# function to check results
def check(fn, hstr):
print('\n** ' + hstr + '\n' + 60*'=')
ds = nc.Dataset(fn)
for vn in ds.variables:
#print(ds[vn])
print(vn + str(ds[vn].dimensions) + ': ' + str(ds[vn][:]))
ds.close()
# output file name
fn = dir0 + 'run test_n test1.nc'
try:
os.remove(fn)
except FileNotFoundError:
pass
# size to use for data
N = 4
hstr = 'Create the original file.'
ds = nc.Dataset(fn, 'w', format='NETCDF4')
#ds = nc.Dataset(fn, 'w', format='NETCDF3_CLASSIC')
# NETCDF3_CLASSIC also works
ds.createDimension('d1', None)
vv = ds.createVariable('data1', float, 'd1')
vv[:] = range(N)
ds.close()
check(fn, hstr)
hstr = 'Add a new variable using an existing dimension.'
ds = nc.Dataset(fn, 'a')
vv = ds.createVariable('data2', float, 'd1')
NN = len(ds.dimensions['d1'])
vv[:] = np.ones(NN)
ds.close()
check(fn, hstr)
hstr = 'Append data to the end of an existing variable.'
ds = nc.Dataset(fn, 'a')
ds.variables['data2'][N: 2*N] = range(N)
ds.close()
check(fn, hstr)
hstr = 'Add a dimension and use it to create a new variable.'
ds = nc.Dataset(fn, 'a')
ds.createDimension('d3', N)
vv = ds.createVariable('data3', float, 'd3')
vv[:] = range(N)
ds.close()
check(fn, hstr)
hstr = 'Replace a variable with zeros.\n NOTE that you cannot delete a variable.'
ds = nc.Dataset(fn, 'a')
ds['data3'][:] = 0.
ds.close()
check(fn, hstr)
|
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import base64
def avg_lap_speed_ts(df, max_speeds, min_speeds):
constructor_names = {'alfa': 'Alfa Romeo', 'alphatauri': 'AlphaTauri',
'mclaren': 'McLaren', 'mercedes': 'Mercedes', 'racing_point': 'Racing Point',
'red_bull': 'Red Bull', 'renault': 'Renault',
'ferrari': 'Ferrari', 'haas': 'Haas', 'williams': 'Williams'}
line_map = {'mercedes': 'solid', 'red_bull': 'solid',
'racing_point': 'dash', 'mclaren': 'solid',
'renault': 'solid', 'ferrari': 'solid', 'alphatauri': 'dot',
'alfa': 'dot', 'haas': 'dash', 'williams': 'dot'}
col_map = {'mercedes': '#484848',
'red_bull': '#4575b4',
'racing_point': '#484848',
'mclaren': '#fc8d59',
'renault': '#fee090',
'ferrari': '#d73027',
'alphatauri': '#4575b4',
'alfa': '#d73027',
'haas': '#d73027',
'williams': '#484848'}
fig = go.Figure()
fig.add_trace(go.Scatter(x=max_speeds['year'], y=max_speeds['avg_lap_speed'],
fill=None,
mode='lines',
line_color='rgb(217, 217, 217)',
hovertemplate='<b>Max Speed: </b>%{y}<br><extra></extra>',
showlegend=False))
fig.add_trace(go.Scatter(x=min_speeds['year'], y=min_speeds['avg_lap_speed'],
fill='tonexty',
mode='lines', line_color='rgb(217, 217, 217)',
hovertemplate='<b>Min Speed: </b>%{y}<br><extra></extra>',
name="Average Speed Range"))
for key, grp in df.groupby(['constructorRef_mapped']):
fig.add_trace(go.Scatter(x=grp['year'], y=grp['avg_lap_speed'],
mode='lines',
line=dict(color=col_map[key], dash=line_map[key]),
name=constructor_names[key],
hovertemplate=
f'<b>Constructor:</b> {constructor_names[key]} <br>' +
'<b>Drivers:</b> %{text}<extra></extra>',
text=df.loc[(df.constructorRef_mapped == key), "drivers"], ))
fig.add_vrect(
x0="1996", x1="2005",
fillcolor="azure", # opacity=0.5,
layer="below", line_width=0,
),
fig.add_vrect(
x0="2005", x1="2013",
fillcolor="cornsilk", # opacity=0.5,
layer="below", line_width=0,
),
fig.add_vrect(
x0="2013", x1="2020",
fillcolor="honeydew", # opacity=0.5,
layer="below", line_width=0,
),
fig.add_annotation(x=2005, y=3.53,
xref="x", yref="y", ax=1996, ay=3.53,
axref="x", ayref="y",
arrowhead=5, arrowside="end+start", arrowsize=1.5, arrowcolor='teal')
fig.add_annotation(x=2000.5, y=3.55, text="<b>V10/12 Engines</b>",
showarrow=False, font=dict(size=18, color='teal'))
fig.add_annotation(x=2005, y=3.53,
xref="x", yref="y", ax=2013, ay=3.53,
axref="x", ayref="y",
arrowhead=5, arrowside="end+start", arrowsize=1.5, arrowcolor='IndianRed')
fig.add_annotation(x=2009, y=3.55, text="<b>V8 Engines</b>",
showarrow=False, font=dict(size=18, color='IndianRed'))
fig.add_annotation(x=2020, y=3.53,
xref="x", yref="y", ax=2013, ay=3.53,
axref="x", ayref="y",
arrowhead=5, arrowside="end+start", arrowsize=1.5, arrowcolor='darkgreen')
fig.add_annotation(x=2016.5, y=3.55, text="<b>V6 Hybrid Engines</b>",
showarrow=False, font=dict(size=18, color='darkgreen'))
fig.update_layout(
autosize=False,
width=1175,
height=800,
plot_bgcolor='rgba(0,0,0,0)',
title=dict(
text="<b>Average Speed by Constructor</b>",
xanchor='left',
yanchor='top',
y=0.92,
x=0.1
),
#legend=dict(
# title_text="<b>Constructors</b>",
#),
yaxis=dict(
range=[2.9, 3.58],
title_text="<b>Km/min</b>",
tickwidth=2,
ticks="outside",
ticklen=10,
tickprefix="<b>", ticksuffix="</b>",
tickfont=dict(size=15),
showline=True,
linewidth=2,
linecolor='black',
gridcolor='lightGray'
),
xaxis=dict(
range=[1995, 2021],
tick0=1996,
dtick=2,
title_text="<b>Year</b>",
tickwidth=2,
ticks="outside",
tickprefix="<b>", ticksuffix="</b>",
ticklen=10,
showline=True,
linewidth=2,
linecolor='black',
gridcolor='lightGray'
),
font=dict(
size=15,
color='black')
)
return fig
def engine_barplot(df, df_exp, df_count):
#with open("logos/ferrari.png", "rb") as image_file_ferrari:
# encoded_string = base64.b64encode(image_file_ferrari.read()).decode()
## Add the prefix that plotly will want when using the string as source
#encoded_image_ferrari = "data:image/png;base64," + encoded_string
#
#with open("logos/mercedes.png", "rb") as image_file_mercedes:
# encoded_string = base64.b64encode(image_file_mercedes.read()).decode()
## Add the prefix that plotly will want when using the string as source
#encoded_image_mercedes = "data:image/png;base64," + encoded_string
#
#with open("logos/renault.png", "rb") as image_file_renault:
# encoded_string = base64.b64encode(image_file_renault.read()).decode()
#encoded_image_renault = "data:image/png;base64," + encoded_string
col_map = {'mercedes': 'royalBlue',
'renault': 'goldenrod',
'ferrari': 'firebrick'}
name_map = {'mercedes': 'Mercedes',
'renault': 'Renault',
'ferrari': 'Ferrari'}
fig = make_subplots(rows=3, cols=1,
shared_xaxes=True,
vertical_spacing=0.05,
# subplot_titles=('<b>Ferrari</b>', '<b>Mercedes</b>', '<b>Renault</b>')
)
i = 1
ypos = [0.95, 0.6, 0.25]
for engine in df['engine'].unique():
leg_bool = True
tl = 10
xtitle = "<b>Year</b>"
ytitle = ""
if i < 3:
leg_bool = False
tl = 0
xtitle = ""
if i == 2:
ytitle = "<b>Win Count</b>"
df1 = df.loc[df.engine == engine, :]
fig.add_trace(go.Bar(
x=df1['year'],
y=df1['engine_win_count'],
name=name_map[engine],
marker_color=col_map[engine],
hovertemplate=
'<b>Year: :</b> %{x} <br>' +
'<b>Win Count: </b>%{y}<extra></extra>',
showlegend=False
), row=i, col=1)
df2 = df_exp.loc[df_exp.engine == engine, :]
fig.add_trace(go.Scatter(
x=df2['year'],
y=df2['expected wins'],
mode='lines+markers',
line=dict(color='black', dash='dash', width=2),
marker=dict(symbol='circle', size=5),
name='<b>Expected Win Count</b>',
hovertemplate=
'<b>Year: :</b> %{x} <br>' +
'<b>Teams With Engine: </b>%{text}<br>' +
'<b>Expected Win Count: </b>%{y}<extra></extra>',
text=df_count.loc[(df_count.engine == engine), "engine_count"],
showlegend=leg_bool
), row=i, col=1)
fig.update_yaxes(
range=[0, 20.5],
title_text=ytitle,
tickwidth=2,
ticks="outside",
ticklen=10,
tickprefix="<b>", ticksuffix="</b>",
tickfont=dict(size=15),
showline=True,
linewidth=2,
linecolor='black',
gridcolor='lightGray',
row=i, col=1),
fig.update_xaxes(
range=[1995, 2020.5],
tick0=1996,
dtick=2,
title_text=xtitle,
tickwidth=2,
ticks="outside",
tickprefix="<b>", ticksuffix="</b>",
ticklen=tl,
showline=True,
linewidth=2,
linecolor='black',
row=i, col=1),
# fig.layout.annotations[i-1].update(x=0.02, y=ypos[i-1], xanchor='left', font=dict(size=20))
i = i + 1
fig.add_vrect(
x0="1995", x1="2005.5",
fillcolor="azure", # opacity=0.5,
layer="below", line_width=0,
),
fig.add_vrect(
x0="2005.5", x1="2013.5",
fillcolor="cornsilk", # opacity=0.5,
layer="below", line_width=0,
),
fig.add_vrect(
x0="2013.5", x1="2021",
fillcolor="honeydew", # opacity=0.5,
layer="below", line_width=0,
),
fig.add_annotation(x=2005.5, y=17,
xref="x", yref="y", ax=1995.5, ay=17,
axref="x", ayref="y",
arrowhead=5, arrowside="end+start", arrowsize=1.5, arrowcolor='teal')
fig.add_annotation(x=2000.5, y=18.5, text="<b>V10/12 Engines</b>",
showarrow=False, font=dict(size=18, color='teal'))
fig.add_annotation(x=2005.5, y=17,
xref="x", yref="y", ax=2013.5, ay=17,
axref="x", ayref="y",
arrowhead=5, arrowside="end+start", arrowsize=1.5, arrowcolor='IndianRed')
fig.add_annotation(x=2009.5, y=18.5, text="<b>V8 Engines</b>",
showarrow=False, font=dict(size=18, color='IndianRed'))
fig.add_annotation(x=2020.5, y=17,
xref="x", yref="y", ax=2013.5, ay=17,
axref="x", ayref="y",
arrowhead=5, arrowside="end+start", arrowsize=1.5, arrowcolor='darkgreen')
fig.add_annotation(x=2017, y=18.5, text="<b>V6 Hybrid Engines</b>",
showarrow=False, font=dict(size=18, color='darkgreen'))
fig.add_layout_image(
dict(
source="https://raw.githubusercontent.com/BiancaMT25/f1-app/master/logos/ferrari.png",
xref="paper", yref="paper",
x=0.15, y=0.84,
sizex=0.15, sizey=0.15,
xanchor="right", yanchor="bottom"
)
)
fig.add_layout_image(
dict(
source="https://raw.githubusercontent.com/BiancaMT25/f1-app/master/logos/mercedes.png",
xref="paper", yref="paper",
x=0.22, y=0.57,
sizex=0.2, sizey=0.2,
xanchor="right", yanchor="bottom"
)
)
fig.add_layout_image(
dict(
source="https://raw.githubusercontent.com/BiancaMT25/f1-app/master/logos/renault.png",
xref="paper", yref="paper",
x=0.17, y=0.23,
sizex=0.15, sizey=0.15,
xanchor="right", yanchor="bottom"
)
)
fig.update_layout(
autosize=False,
width=1000,
height=800,
plot_bgcolor='rgba(0,0,0,0)',
title=dict(
text="<b>F1 Grand Prix Wins by Engine Manufacturer </b>",
xanchor='left',
yanchor='top',
y=0.92,
x=0.1
),
legend=dict(
orientation="h",
yanchor="bottom", y=1.02,
xanchor="right", x=1
),
font=dict(
size=15,
color='black')
)
return fig
|
numbers = []
while True:
n = int(input())
numbers.append(n)
if n < 0:
numbers.pop()
avg = sum(numbers)/len(numbers)
print('{:.2f}'.format(avg))
break
|
# Teste seu codigo aos poucos.
# Nao teste tudo no final, pois fica mais dificil de identificar erros.
# Nao se intimide com as mensagens de erro. Elas ajudam a corrigir seu codigo.
var = float(input("Quantos litros foram comprados?"))
total = var * 1/3
print(round(var * 1/3, 3 ))
|
#!/usr/bin/python
import string
import time
import numpy as np
import os
import glob
import matplotlib
import matplotlib.pyplot as plt
import math
import colorsys
import cStringIO
import cPickle as pickle
from snap.iw import iw_pb2
from snap.iw.matching import py_featureextractor
from snap.iw.matching import py_featurematcher
from snap.pyglog import *
from snap.tomato import py_tomato
from mpl_toolkits.mplot3d import Axes3D
import vis
import image_matcher_config
from snap.iw.matching import py_imagematcher
def CreateRansacMatcher():
config = image_matcher_config.GetImageMatcherConfig('usift')
matcher = py_imagematcher.CreateImageMatcherOrDie(config)
return matcher
def GenerateDistinctColorsRGB(N, alpha = None):
HSV_tuples = [(x*1.0/N, 0.9, 1.0) for x in range(N)]
RGB_tuples = map(lambda x: colorsys.hsv_to_rgb(*x), HSV_tuples)
RGBA_tuples = [[rgb[0], rgb[1], rgb[2], alpha] for rgb in RGB_tuples]
return RGBA_tuples
def CreateFeatureExtractor():
params = iw_pb2.FeatureExtractorParams()
params.ocv_sift_params.num_octave_layers = 3
params.ocv_sift_params.contrast_threshold = 0.04
params.ocv_sift_params.edge_threshold = 30
params.ocv_sift_params.sigma = 1.2
params.ocv_sift_params.upright = True
params.ocv_sift_params.root_sift_normalization = False
CHECK(params.ocv_sift_params.IsInitialized())
extractor = py_featureextractor.CreateFeatureExtractorOrDie(params)
return extractor
class Dataset(object):
def __init__(self):
self.imageid_to_filename = {}
self.imageid_to_classid = {}
self.classid_to_classname = {}
self.imageids = []
return
def Load(self, dataset_path):
# get list of directories / objects
subdirs = [x[0] for x in os.walk(dataset_path) if x[0] != dataset_path]
for class_id, subdir in enumerate(subdirs):
files = glob.glob('%s/*.jpg' % (subdir))
classname = os.path.basename(subdir)
print 'classname: %s' % (classname)
self.classid_to_classname[class_id] = classname
for file in files:
image_filename = os.path.basename(file)
image_id = int(image_filename[0:-4])
self.imageids.append(image_id)
print ' %d' % (image_id)
self.imageid_to_filename[image_id] = file
self.imageid_to_classid[image_id] = class_id
return
def FilterTomatoCorrespondences(in_correspondences, features_a, features_b):
# find the smallest match distance for each point...
num_features_a = len(features_a.keypoints)
num_features_b = len(features_b.keypoints)
indexa_to_minmatchdist = [1e10]*num_features_a
indexb_to_minmatchdist = [1e10]*num_features_b
for c in in_correspondences:
ia, ib = c.index_a, c.index_b
indexa_to_minmatchdist[ia] = min(indexa_to_minmatchdist[ia], c.dist)
indexb_to_minmatchdist[ib] = min(indexb_to_minmatchdist[ib], c.dist)
out_correspondences = []
for c in in_correspondences:
ia, ib = c.index_a, c.index_b
# discard matches that are not close to the best match distance involving this point
# helps remove matches to the same point that are much worse than the best
if c.dist > 1.1*indexa_to_minmatchdist[ia] or c.dist > 1.1*indexb_to_minmatchdist[ib]:
continue
out_correspondences.append(c)
return out_correspondences
class ImagePairData(object):
def __init__(self):
self.features_a = None
self.features_b = None
return
def ExtractFeatures(dataset):
imagepair_data = {} # maps (image_a_id, image_b_id) to
imageid_to_imagefeatures = {}
extractor = CreateFeatureExtractor()
for image_id in dataset.imageids:
filename = dataset.imageid_to_filename[image_id]
imagedata = open(filename, 'rb').read()
ok, features = extractor.Run(imagedata)
CHECK(ok)
imageid_to_imagefeatures[image_id] = features
return imageid_to_imagefeatures
def LoadData(dataset_name):
dataset = Dataset()
dataset.Load('../data/%s' % (dataset_name))
imagepair_data = None
match_data_cache_filename = 'features_cache_%s.dat' % (dataset_name)
if os.path.exists(match_data_cache_filename):
print 'Using data from cache: %s ' % (match_data_cache_filename)
imagepair_data = pickle.load(open(match_data_cache_filename, 'rb'))
else:
imagepair_data = ExtractFeatures(dataset)
pickle.dump(imagepair_data, open(match_data_cache_filename, 'wb'))
return dataset, imagepair_data
def GenerateTomatoClusters(features_a, features_b, num_neighbors, rips_radius, persistence_threshold):
num_features_a = len(features_a.keypoints)
num_features_b = len(features_b.keypoints)
CHECK_EQ(len(features_a.keypoints), len(features_a.descriptors))
CHECK_EQ(len(features_b.keypoints), len(features_b.descriptors))
matcher = py_featurematcher.BidirectionalFeatureMatcher()
ok, correspondences_a_or_b, correspondences_a_and_b = matcher.Run(features_a, features_b)
CHECK(ok)
correspondences_tomato = FilterTomatoCorrespondences(correspondences_a_or_b, features_a, features_b)
tranform_points = []
for c in correspondences_tomato:
ia, ib = c.index_a, c.index_b
ka, kb = features_a.keypoints[ia], features_b.keypoints[ib]
scale_atob = kb.radius / ka.radius
# apply inverse of scaling a->b to put pos in b in same scale as pos in a
tx_atob = kb.pos.x/scale_atob - ka.pos.x
ty_atob = kb.pos.y/scale_atob - ka.pos.y
log_scale_atob = math.log(scale_atob,2)
tranform_point = [tx_atob, ty_atob, log_scale_atob, ka.pos.x, ka.pos.y, ka.radius, kb.pos.x, kb.pos.y, kb.radius]
tranform_points.append(tranform_point)
tomato_data = np.array(tranform_points)
logscale_stretch = 4
transform_data = tomato_data[:,0:3] # first 3 columns are dx, dy, ds
# rescale the scale so it has similar range as dx dy
transform_data[:,2] = transform_data[:,2]*logscale_stretch
tomato_clusters = py_tomato.cluster(transform_data, num_neighbors, rips_radius, persistence_threshold)
# keep only clusters with at least 10 votes
#min_votes = 10
min_votes = 3
top_clusters = [c for c in tomato_clusters if len(c.member_indices) > min_votes]
# keep only top 3 clusters
top_clusters = top_clusters[0:3]
return transform_data, tomato_data, top_clusters
def RenderFigureToSvg():
mem_file = cStringIO.StringIO()
plt.savefig(mem_file, format='svg')
svg = mem_file.getvalue()
mem_file.close()
return svg
def RenderTomatoClusterResults(image_a_filename, image_b_filename, transform_data, tomato_data, top_clusters, tomato_diagram):
num_points = tomato_data.shape[0]
num_nontrival_clusters = len(top_clusters)
colors = GenerateDistinctColorsRGB(num_nontrival_clusters, 1.0)
index_to_color = [[0,0,0, 0.1]]*num_points
clusters_to_matches = []
for i, cluster in enumerate(top_clusters):
indices = [v for v in cluster.member_indices]
cluster_size = len(indices)
for index in indices:
index_to_color[index] = colors[i]
print i, cluster.persistence, cluster_size
cluster_matches = tomato_data[indices,3:10]
clusters_to_matches.append(cluster_matches)
match_svg = vis.RenderMatchSVG(image_a_filename, image_b_filename, clusters_to_matches, colors)
cluster_info_table = ''
if top_clusters:
cluster_info_table += '<table>'
cluster_info_table += '<tr><th>Cluster</th><th>Persistence</th><th>Size</th></tr>'
for i, cluster in enumerate(top_clusters):
indices = [v for v in cluster.member_indices]
cluster_size = len(indices)
cluster_info_table += '<tr>'
cluster_info_table += '<tr><td style="background-color:%s">%d</td><td>%f</td><td>%d</td></tr>' % (vis.UnityRgbToCssString(colors[i]), i, cluster.persistence, cluster_size )
cluster_info_table += '</tr>'
cluster_info_table += '</table>'
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(transform_data[:,0], transform_data[:,1], transform_data[:,2], c=index_to_color, marker='o')
ax.set_xlim3d(-200,200)
ax.set_ylim3d(-200,200)
ax.set_ylim3d(-200,200)
ax.set_xlabel('DX')
ax.set_ylabel('DY')
ax.set_zlabel('DS')
transform_space_svg = RenderFigureToSvg()
# draw persistence diagram
fig = plt.figure()
x = []
y = []
for p in tomato_diagram:
x.append(p.birth)
y.append(p.death)
lim = max(max(x), max(y))*1.1
plt.plot(x,y,'ro', [0, lim], [0, lim], 'k--')
plt.xlabel('Birth')
plt.ylabel('Death')
plt.title('Persistence Diagram')
plt.xlim([0, lim])
plt.ylim([0, lim])
#plt.show()
persistence_diagram_svg = RenderFigureToSvg()
return cluster_info_table, transform_space_svg, match_svg, persistence_diagram_svg
def RenderRansacResults(image_a_filename, image_b_filename, ransac_geometric_matches):
num_ransac_matches = len(ransac_geometric_matches.entries)
colors = GenerateDistinctColorsRGB(num_ransac_matches, 1.0)
match_sets = []
for gm in ransac_geometric_matches.entries:
matches = []
for c in gm.correspondences:
matches.append([c.a.pos.x, c.a.pos.y, c.a.radius, c.b.pos.x, c.b.pos.y, c.b.radius])
match_sets.append(matches)
match_svg = vis.RenderMatchSVG(image_a_filename, image_b_filename, match_sets, colors)
return match_svg
def RenderParamsHtml(rips_radius, num_neighbors, persistence_threshold, time_tomato, time_ransac):
html = ''
html += '<ul>'
html += '<li> rips_radius: %f' % (rips_radius)
html += '<li> num_neighbors: %d' % (num_neighbors)
html += '<li> persistence_threshold: %f' % (persistence_threshold)
html += '<li> time_tomato: %f' % (time_tomato)
html += '<li> time_ransac: %f' % (time_ransac)
html += '</ul>'
return html
class ErrorRateExperiment(object):
def __init__(self):
self.tp = 0
self.fp = 0
self.fn = 0
self.tn = 0
self.total_time = 0
return
def AvgTime(self):
return self.total_time / (self.tp + self.fp + self.fn + self.tn)
def AddResult(self, actual, predicted, time):
CHECK(actual in [True, False])
CHECK(predicted in [True, False])
if actual:
if predicted:
self.tp += 1.0
else:
self.fn += 1.0
else:
if predicted:
self.fp += 1.0
else:
self.tn += 1.0
self.total_time += time
return
def Precision(self):
return self.tp / (self.tp+self.fp)
def Recall(self):
return self.tp / (self.tp+self.fn)
def FScore(self, beta = 1.0):
precision = self.Precision()
recall = self.Recall()
eps = 1e-16
f = (1.0+beta*beta)*precision*recall/(beta*beta*precision + recall + eps)
return f
def __str__(self):
return 'P: %f R: %f F: %f t:%f' % (self.Precision(), self.Recall(), self.FScore(), self.AvgTime())
def main():
dataset_name = 'set04'
output_results_html = False
rips_radius=9
num_neighbors=20
persistence_threshold=0.0015
# rips_radius=20
# num_neighbors=20
# persistence_threshold=0.002
# rips_radius=30
# num_neighbors=20
# persistence_threshold=0.002
dataset, imageid_to_imagefeatures = LoadData(dataset_name)
ransac = CreateRansacMatcher()
num_images = len(dataset.imageids)
t_exp = ErrorRateExperiment()
r_exp = ErrorRateExperiment()
tr_exp = ErrorRateExperiment()
template_filename = 'exp_result_template.html'
html_template = string.Template(open(template_filename, 'r').read())
for i in range(num_images):
image_a = dataset.imageids[i]
for j in range(i+1, num_images):
image_b = dataset.imageids[j]
CHECK_NE(image_a, image_b)
features_a = imageid_to_imagefeatures[image_a]
features_b = imageid_to_imagefeatures[image_b]
classid_a, classid_b = [dataset.imageid_to_classid[id] for id in [image_a, image_b]]
image_a_filename, image_b_filename = [dataset.imageid_to_filename[id] for id in [image_a, image_b]]
are_same_class = (classid_a == classid_b)
print '%s \n%s' % (image_a_filename, image_b_filename)
time_start = time.time()
transform_data, tomato_data, top_clusters = GenerateTomatoClusters(features_a, features_b, num_neighbors, rips_radius, persistence_threshold)
time_tomato = time.time() - time_start
tomato_found_match = (len(top_clusters) > 0)
time_start = time.time()
ransac_found_match, ransac_results, cpptime = ransac.Run(features_a, features_b)
time_ransac = time.time() - time_start
print 'tomato: %s ransac: %s' % (tomato_found_match, ransac_found_match)
if not are_same_class and ransac_found_match:
print 'Look at me! ****************************'
if output_results_html:
tomato_diagram = py_tomato.diagram(transform_data, num_neighbors, rips_radius)
cluster_info_table, transform_space_svg, cluster_match_svg, persistence_diagram_svg = RenderTomatoClusterResults(image_a_filename, image_b_filename, transform_data, tomato_data, top_clusters, tomato_diagram)
ransac_match_svg = RenderRansacResults(image_a_filename, image_b_filename, ransac_results)
params_html = RenderParamsHtml(rips_radius, num_neighbors, persistence_threshold, time_tomato, time_ransac)
html = html_template.substitute({'cluster_info_table' : cluster_info_table,
'transform_space_svg' : transform_space_svg,
'cluster_match_svg' : cluster_match_svg,
'persistence_diagram_svg': persistence_diagram_svg,
'ransac_match_svg' : ransac_match_svg,
'params_html': params_html })
prefix = 'sameclass' if are_same_class else 'diffclass'
result_filename = 'results/%s_class%d_class%d_image%s_to_image%s.html' % (prefix, classid_a, classid_b, image_a, image_b)
open(result_filename, 'w').write(html)
# evaluate error rates
t_exp.AddResult(are_same_class, tomato_found_match, time_tomato)
r_exp.AddResult(are_same_class, ransac_found_match, time_ransac)
time_tr = time_tomato
tr_found_match = False
if tomato_found_match:
time_tr += time_ransac
if ransac_found_match:
tr_found_match = True
tr_exp.AddResult(are_same_class, tr_found_match, time_tr)
print 't : %s' % (t_exp)
print 'r : %s' % (r_exp)
print 't+r: %s' % (tr_exp)
return
if __name__ == "__main__":
main() |
from rest_framework import serializers
from .models import app
class appSerializer(serializers.ModelSerializer):
class Meta:
model = app
fields = ('id', 'username', 'lastname', 'age','weight','gender') |
N = int(input("Digite o número:") )
soma = 0
while N >= 1:
digito = N % 10
N = N // 10
soma = digito + soma
print("A soma dos dígitos é", soma) |
# D-Wave Leap access: https://cloud.dwavesys.com/leap/
#
# Docs for QPU / Hybrid samplers
# https://docs.ocean.dwavesys.com/projects/system/en/stable/reference/samplers.html#dwave.system.samplers.LeapHybridDQMSampler
# pip install numpy
# pip install dimod
# pip install dwave-hybrid
# pip install dwave-system
import numpy as np
import dimod
from hybrid.reference.kerberos import KerberosSampler
from dwave.system import LeapHybridSampler
from dwave.system import DWaveSampler
mat = np.array(
[[1.0, 50000, 50000, 1121.0, 1122.0, 1123.0, 1124.0, 1131.0, 1132.0, 1133.0],
[0, 2.0, 50000, 1221.0, 1222.0, 1223.0, 1224.0, 1231.0, 1232.0, 1233.0],
[0, 0, 3.0, 1321.0, 1322.0, 1323.0, 1324.0, 1331.0, 1332.0, 1333.0],
[0, 0, 0, 4.0, 50000, 50000, 50000, 2131.0, 2132.0, 2133.0],
[0, 0, 0, 0, 5.0, 50000, 50000, 2231.0, 2232.0, 2233.0],
[0, 0, 0, 0, 0, 6.0, 50000, 2331.0, 2332.0, 2333.0],
[0, 0, 0, 0, 0, 0, 7.0, 2431.0, 2432.0, 2433.0],
[0, 0, 0, 0, 0, 0, 0, 8.0, 50000, 50000 ],
[0, 0, 0, 0, 0, 0, 0, 0, 9.0, 50000 ],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 10.0 ]]
)
# [ pos 0 ][ pos 1 ][ pos 2 ]
# (0, 0) <-> (1, 3) <-> (2, 1)
mat2 = np.array(
[[-100.0, 50000, 50000, -1121.0, 1122.0, 1123.0, -1124.0, 1131.0, 1132.0, -1133.0],
[0, 200.0, 50000, 1221.0, 1222.0, 1223.0, 1224.0, 1231.0, 1232.0, -1233.0],
[0, 0, -300.0, -1321.0, 1322.0, -1323.0, 1324.0, 1331.0, 1332.0, 1333.0],
[0, 0, 0, 400.0, 50000, 50000, 50000, -2131.0, 2132.0, -2133.0],
[0, 0, 0, 0, -500.0, 50000, 50000, 2231.0, -2232.0, 2233.0],
[0, 0, 0, 0, 0, 600.0, 50000, -2331.0, 2332.0, -2333.0],
[0, 0, 0, 0, 0, 0, -700.0, 2431.0, -2432.0, 2433.0],
[0, 0, 0, 0, 0, 0, 0, 800.0, 50000, 50000 ],
[0, 0, 0, 0, 0, 0, 0, 0, -900.0, 50000 ],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 10.0 ]]
)
variable_order = [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2)]
bqm = dimod.BinaryQuadraticModel.from_numpy_matrix(mat, variable_order)
# print(bqm)
solution = KerberosSampler().sample(bqm, max_iter=10, convergence=3)
print("Energy for all positive:", solution.first.energy)
bqm2 = dimod.BinaryQuadraticModel.from_numpy_matrix(mat2, variable_order)
solution2 = KerberosSampler().sample(bqm2, max_iter=10, convergence=3)
print("Energy for mixed:", solution2.first.energy)
print("Solution:", solution2.first)
hybrid = LeapHybridSampler().sample(bqm2)
print("[HYBRID] Energy for mixed:", hybrid.first.energy)
print("[HYBRID] Solution:", hybrid.first)
dwave = DWaveSampler().sample(bqm2)
print("[DWAVE] Energy for mixed:", dwave.first.energy)
print("[DWAVE] Solution:", dwave.first)
# > Energy for all positive: 0.0
# > Energy for mixed: -4124.0
# > Solution: Sample(sample={(0, 0): 1, (0, 1): 0, (0, 2): 0, (1, 0): 0, (1, 1): 0, (1, 2): 0, (1, 3): 1, (2, 0): 0, (2, 1): 1, (2, 2): 0}, energy=-4124.0, num_occurrences=1)
# > [HYBRID] Energy for mixed: -4124.0
# > [HYBRID] Solution: Sample(sample={(0, 0): 1, (0, 1): 0, (0, 2): 0, (1, 0): 0, (1, 1): 0, (1, 2): 0, (1, 3): 1, (2, 0): 0, (2, 1): 1, (2, 2): 0}, energy=-4124.0, num_occurrences=1)
# Traceback (most recent call last):
# File "/workspace/simanneal/app.py", line 53, in <module>
# dwave = DWaveSampler().sample(bqm2)
# File "/usr/local/lib/python3.7/site-packages/dwave/system/samplers/dwave_sampler.py", line 46, in wrapper
# return f(sampler, *args, **kwargs)
# File "/usr/local/lib/python3.7/site-packages/dwave/system/samplers/dwave_sampler.py", line 342, in sample
# raise BinaryQuadraticModelStructureError(msg)
# dimod.exceptions.BinaryQuadraticModelStructureError: Problem graph incompatible with solver.
|
from django.contrib import admin
from etat_civil.deeds.jobs import import_data_async
from etat_civil.deeds.models import (
Data,
Deed,
DeedType,
Gender,
Origin,
OriginType,
Party,
Person,
Profession,
Role,
Source,
)
class BaseALAdmin(admin.ModelAdmin):
list_display = ["title"]
search_fields = ["title"]
@admin.register(Data)
class DataAdmin(admin.ModelAdmin):
list_display = ["title", "data"]
def save_model(self, request, obj, form, change):
super().save_model(request, obj, form, change)
import_data_async.delay(obj)
class PartyInline(admin.TabularInline):
model = Party
autocomplete_fields = ["deed", "person", "profession", "role"]
extra = 1
@admin.register(Deed)
class DeedAdmin(admin.ModelAdmin):
autocomplete_fields = ["deed_type", "place", "source"]
date_hierarchy = "date"
inlines = [PartyInline]
list_display = ["n", "date", "deed_type", "place", "source"]
list_filter = ["deed_type", "place"]
search_fields = [
"n",
"date__year",
"deed_type__title",
"place__address",
"source__classmark",
]
@admin.register(DeedType)
class DeedTypeAdmin(BaseALAdmin):
pass
@admin.register(Gender)
class GenderAdmin(BaseALAdmin):
pass
@admin.register(OriginType)
class OriginType(BaseALAdmin):
pass
class OriginInline(admin.TabularInline):
model = Origin
autocomplete_fields = ["origin_type", "place"]
extra = 1
@admin.register(Person)
class PersonAdmin(admin.ModelAdmin):
inlines = [OriginInline, PartyInline]
list_display = [
"name",
"surname",
"gender",
"age",
"birth_year",
"get_origin_names",
]
list_display_links = list_display
list_filter = ["gender", "age", "surname"]
search_fields = ["name", "surname", "origin_from__place__address"]
@admin.register(Origin)
class OriginAdmin(admin.ModelAdmin):
autocomplete_fields = ["person", "place", "origin_type"]
date_hierarchy = "date"
list_display = ["person", "place", "origin_type", "date"]
list_filter = ["origin_type", "place"]
@admin.register(Profession)
class ProfessionAdmin(BaseALAdmin):
pass
@admin.register(Role)
class RoleAdmin(BaseALAdmin):
pass
@admin.register(Source)
class SourceAdmin(admin.ModelAdmin):
list_display = ["classmark", "microfilm"]
search_fields = ["classmark", "microfilm"]
|
# -*- coding: utf-8 -*-
"""
Created on Thu Dec 24 17:24:39 2015
Sample use cases of the HackerNews API
@author: Rupak Chakraborty
"""
import HackerNewsUser as HNUser
import HackerNews as HN
def sample():
user = HNUser.User("pg")
user.userProcessingPipeline()
print "User Id : ",user.Id
print "Creation Time : ", user.created_at_i
print "Submission Count : ", user.submission_count
print "Username : ", user.username
print "Submitted : ", user.submitted
print "About : ", user.about
print "Karma : ", user.karma
print "Comment Count : ", user.comment_count
print "Created At : ", user.created_at
print "Avg Rating : ", user.avg
print "Delay : ", user.delay
print "Updated At : ", user.updated_at
print "Object ID : ", user.objectId
def sampleQuery():
query = HN.QueryResult("internet")
query.postProcessingPipeline()
for post in query.postList:
print "------------------------------------------------------"
print "Post Created : ", post.created_at
print "Post Title : ", post.title
print "Post Url : ", post.url
print "Post Author : ", post.author
print "Post Points : ", post.points
print "Story Text : ", post.story_text
print "Comment Text : ", post.comment_text
print "Number of Comments : ", post.num_comments
print "Story Id : ", post.story_id
print "Story Title : ", post.story_title
print "Story Url : ", post.story_url
print "Parent Id : ", post.parent_id
print "Created At i : ", post.created_at_i
print "Tags : ", post.tags
print "ObjectID : ", post.objectID
print "------------------------------------------------------"
sample()
sampleQuery() |
from turtle import Turtle, Screen
import random
import turtle
tim=Turtle()
turtle.colormode(255)
colours=["CornflowerBlue", "DarkOrchid", "IndianRed", "DeepSkyBlue", "LightSeaGreen", "wheat", "SlateGray", "SeaGreen"]
'''Square'''
# tim.forward(100)
# tim.left(90)
# tim.forward(100)
# tim.left(90)
# tim.forward(100)
# tim.left(90)
# tim.forward(100)
# tim.left(90)
'''Dotted line'''
# for _ in range(10):
# tim.forward(10)
# tim.penup()
# tim.forward(10)
# tim.pendown()
'''Shapes'''
# def draw_shape(num_of_sides):
# angle=360/num_of_sides
# for _ in range(num_of_sides):
# tim.forward(100)
# tim.right(angle)
# for shape_in_side_n in range(3, 11):
# tim.color(random.choice(colours))
# draw_shape(shape_in_side_n)
'''Random walk'''
directions=[0, 90, 180, 270]
def random_color():
r=random.randint(0, 255)
g=random.randint(0, 255)
b=random.randint(0, 255)
random_color=(r, g , b)
return random_color
tim.pensize(10)
tim.speed("fastest")
for _ in range(200):
tim.color(random_color())
tim.forward(30)
tim.setheading(random.choice(directions))
screen=Screen()
screen.exitonclick()
|
# -*- coding: utf-8 -*-
"""
Created on Tue Feb 26 18:33:14 2019
@author: vkrin
"""
x=list(map(int, input().split(' ')))
if ((x[0]-x[1])%2==0):
for i in range(x[0]-x[1]):
if (i+1)%2==0:
print(2, end=' ')
else: print(1, end=' ')
for j in range(x[1]):
print(j+1, end=' ')
else:
for i in range(x[0]-x[1]+1):
if (i+1)%2==0:
print(2, end=' ')
else: print(1, end=' ')
for j in range(x[1]):
j+=1
if j!=2:
print(j, end=' ')
|
from AnagramDrawer import *
ad = AnagramDrawer()
ad.draw_image("Guilherme Kuro","Leg Hike Rumour","out.png")
|
"""
Django settings for gb_blog project.
Generated by 'django-admin startproject' using Django 1.11.16.
For more information on this file, see
https://docs.djangoproject.com/en/1.11/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.11/ref/settings/
"""
import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'yf)z1rw+85u=%$^x85+!edenxn^6zv%n%s4e^p95y4=3qav1$h'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = ['*']
# mdeditor markdown编辑器配置
MDEDITOR_CONFIGS = {
'default':{
'width': '90%', # 自定义编辑框宽度
'heigth': 500, # 自定义编辑框高度
'toolbar': ["undo", "redo", "|",
"bold", "del", "italic", "quote", "ucwords", "uppercase", "lowercase", "|",
"h1", "h2", "h3", "h5", "h6", "|",
"list-ul", "list-ol", "hr", "|",
"link", "reference-link", "image", "code", "preformatted-text", "code-block", "table", "datetime",
"emoji", "html-entities", "pagebreak", "goto-line", "|",
"help", "info",
"||", "preview", "watch", "fullscreen"], # 自定义编辑框工具栏
'upload_image_formats': ["jpg", "jpeg", "gif", "png", "bmp", "webp"], # 图片上传格式类型
'image_floder': 'editor', # 图片保存文件夹名称
'theme': 'default', # 编辑框主题 ，dark / default
'preview_theme': 'default', # 预览区域主题， dark / default
'editor_theme': 'default', # edit区域主题，pastel-on-dark / default
'toolbar_autofixed': True, # 工具栏是否吸顶
'search_replace': True, # 是否开启查找替换
'emoji': True, # 是否开启表情功能
'tex': True, # 是否开启 tex 图表功能
'flow_chart': True, # 是否开启流程图功能
'sequence': True # 是否开启序列图功能
},
'form_config': {
'width': '70%', # 自定义编辑框宽度
'heigth': 500, # 自定义编辑框高度
'toolbar': ["undo", "redo", "|", "link", "reference-link", "image", "code", "preformatted-text", "code-block", "table",
"emoji", "|",
"help", "info", "preview", "watch", "fullscreen"], # 自定义编辑框工具栏
'upload_image_formats': ["jpg", "jpeg", "gif", "png", "bmp", "webp"], # 图片上传格式类型
'image_floder': 'editor', # 图片保存文件夹名称
'theme': 'dark', # 编辑框主题 ，dark / default
'preview_theme': 'default', # 预览区域主题， dark / default
'editor_theme': 'default', # edit区域主题，pastel-on-dark / default
'toolbar_autofixed': True, # 工具栏是否吸顶
'search_replace': True, # 是否开启查找替换
'emoji': True, # 是否开启表情功能
'tex': True, # 是否开启 tex 图表功能
'flow_chart': True, # 是否开启流程图功能
'sequence': True # 是否开启序列图功能
},
}
# Application definition
INSTALLED_APPS = [
'bootstrap_admin',
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'article',
'mdeditor'
]
# from django.conf import global_settings
# TEMPLATE_CONTEXT_PROCESSORS = global_settings.TEMPLATE_CONTEXT_PROCESSORS + (
# 'django.core.context_processors.request',
# )
# BOOTSTRAP_ADMIN_SIDEBAR_MENU = True
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'gb_blog.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
'libraries':{
'blog_tags' : 'templatetags.blog_tags',
}
},
},
]
WSGI_APPLICATION = 'gb_blog.wsgi.application'
# Database
# https://docs.djangoproject.com/en/1.11/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# Password validation
# https://docs.djangoproject.com/en/1.11/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# TEMPLATE_PATH = os.path.join(BASE_DIR, 'templates')
# TEMPLATE_DIRS = (
# TEMPLATE_PATH,
# )
# Internationalization
# https://docs.djangoproject.com/en/1.11/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.11/howto/static-files/
STATIC_URL = '/static/'
|
# This is a program for getting which number is negative and which is positive.
the_number = input('Enter any number')
print(the_number)
if int(the_number) >= 0:
print("The number you entered is a positive number")
else:
print("The number you entered is negative number")
|
# A simple Json Web Server
import re
import json
# from socket_server import WSGIServer
from asynic_server import server_run
from urllib import parse
class BaseHttpServer(object):
def __init__(self):
self.routes = []
self.router = Router()
self.request_method = None
self.path = ''
def __call__(self, env, start_response):
return self.wsgi_app(env, start_response)
def wsgi_app(self, env, start_response):
self.request_method = env['REQUEST_METHOD']
self.path = env['PATH_INFO']
try:
route, args = self.router.match(env)
output = route.call(**args)
except HttpErrorResponse as e:
output = e
if isinstance(output, str):
response = Response(body=output)
elif isinstance(output, dict):
response = Response(body=json.dumps(output))
elif isinstance(output, Response):
response = output
else:
response = HttpErrorResponse(500, self.path, 'unknown error')
start_response(response.status, response.response_header)
return response.content()
def route(self, path=None, method='GET', callback=None, name=None):
if callable(path):
path, callback = None, path
def decorator(fn):
for rule in make_list(path):
for verb in make_list(method):
verb = verb.upper()
route = Route(self, rule, verb, fn, name=name)
self.add_route(route)
return fn
return decorator(callback) if callback else decorator
def add_route(self, route):
self.routes.append(route)
self.router.add(route.rule, route.method, route, name=route.name)
def run(self, host='', port=8081):
server_addr = (host, port)
server_run(server_addr, self)
def make_list(data): # This is just to handy
if isinstance(data, (tuple, list, set, dict)):
return list(data)
elif data:
return [data]
else:
return []
def _re_flatten(p):
""" Turn all capturing groups in a regular expression pattern into
non-capturing groups. """
if '(' not in p:
return p
return re.sub(r'(\\*)(\(\?P<[^>]+>|\((?!\?))', lambda m: m.group(0) if len(m.group(1)
) % 2 else m.group(1) + '(?:', p)
class Router(object):
default_pattern = '[^/]+'
default_filter = 're'
def __init__(self, strict=False):
self.rules = [] # All rules in order
self._groups = {} # index of regexes to find them in dyna_routes
self.builder = {} # Data structure for the url builder
self.static = {} # Search structure for static routes
self.dyna_routes = {}
self.dyna_regexes = {} # Search structure for dynamic routes
#: If true, static routes are no longer checked first.
self.strict_order = strict
self.filters = {
're': lambda conf:
(_re_flatten(conf or self.default_pattern), None, None),
'int': lambda conf: (r'-?\d+', int, lambda x: str(int(x))),
'float': lambda conf: (r'-?[\d.]+', float, lambda x: str(float(x))),
'path': lambda conf: (r'.+?', None, None)}
rule_syntax = re.compile('(\\\\*)'
'(?:(?::([a-zA-Z_][a-zA-Z_0-9]*)?( )(?:#(.*?)#)?)'
'|(?:<([a-zA-Z_][a-zA-Z_0-9]*)?(?::([a-zA-Z_]*)'
'(?::((?:\\\\.|[^\\\\>]+)+)?)?)?>))')
def add_filter(self, name, func):
""" Add a filter. The provided function is called with the configuration
string as parameter and must return a (regexp, to_python, to_url) tuple.
The first element is a string, the last two are callables or None. """
self.filters[name] = func
def _itertokens(self, rule):
offset, prefix = 0, ''
for match in self.rule_syntax.finditer(rule):
prefix += rule[offset:match.start()]
g = match.groups()
if len(g[0]) % 2: # Escaped wildcard
prefix += match.group(0)[len(g[0]):]
offset = match.end()
continue
if prefix:
yield prefix, None, None
name, filtr, conf = g[4:7] if g[2] is None else g[1:4]
yield name, filtr or 'default', conf or None
offset, prefix = match.end(), ''
if offset <= len(rule) or prefix:
yield prefix + rule[offset:], None, None
def add(self, rule, method, target, name=None):
""" Add a new rule or replace the target for an existing rule. """
anons = 0 # Number of anonymous wildcards found
keys = [] # Names of keys
pattern = '' # Regular expression pattern with named groups
filters = [] # Lists of wildcard input filters
builder = [] # Data structure for the URL builder
is_static = True
for key, mode, conf in self._itertokens(rule):
if mode:
is_static = False
if mode == 'default':
mode = self.default_filter
mask, in_filter, out_filter = self.filters[mode](conf)
if not key:
pattern += '(?:%s)' % mask
key = 'anon%d' % anons
anons += 1
else:
pattern += '(?P<%s>%s)' % (key, mask)
keys.append(key)
if in_filter:
filters.append((key, in_filter))
builder.append((key, out_filter or str))
elif key:
pattern += re.escape(key)
builder.append((None, key))
self.builder[rule] = builder
if name:
self.builder[name] = builder
if is_static and not self.strict_order:
self.static.setdefault(method, {})
self.static[method][self.build(rule)] = (target, None)
return
try:
re_pattern = re.compile('^(%s)$' % pattern)
re_match = re_pattern.match
except re.error:
raise Exception("Could not add Route: %s " % rule)
if filters:
def getargs(path):
url_args = re_match(path).groupdict()
for u_name, wildcard_filter in filters:
try:
url_args[u_name] = wildcard_filter(url_args[u_name])
except ValueError:
raise HttpErrorResponse(400, path, 'Path has wrong format.')
return url_args
elif re_pattern.groupindex:
def getargs(path):
return re_match(path).groupdict()
else:
getargs = None
flatpat = _re_flatten(pattern)
whole_rule = (rule, flatpat, target, getargs)
if (flatpat, method) in self._groups:
self.dyna_routes[method][self._groups[flatpat, method]] = whole_rule
else:
self.dyna_routes.setdefault(method, []).append(whole_rule)
self._groups[flatpat, method] = len(self.dyna_routes[method]) - 1
self._compile(method)
def match(self, environ):
""" Return a (target, url_agrs) tuple or raise HTTPError(400/404/405). """
verb = environ['REQUEST_METHOD'].upper()
path = environ['PATH_INFO'] or '/'
methods = ['PROXY', verb, 'ANY']
for method in methods:
if method in self.static and path in self.static[method]:
target, getargs = self.static[method][path]
return target, getargs(path) if getargs else {}
elif method in self.dyna_regexes:
for combined, rules in self.dyna_regexes[method]:
match = combined(path)
if match:
target, getargs = rules[match.lastindex - 1]
return target, getargs(path) if getargs else {}
# No matching route found. Collect alternative methods for 405 response
allowed = set([])
nocheck = set(methods)
for method in set(self.static) - nocheck:
if path in self.static[method]:
allowed.add(verb)
for method in set(self.dyna_regexes) - allowed - nocheck:
for combined, rules in self.dyna_regexes[method]:
match = combined(path)
if match:
allowed.add(method)
if allowed:
raise HttpErrorResponse(405, path, 'Method not allowed.')
# No matching route and no alternative method found. We give up
# raise HTTPError(404, "Not found: " + repr(path))
raise HttpErrorResponse(404, path, 'Response not Found.')
def _compile(self, method):
all_rules = self.dyna_routes[method]
comborules = self.dyna_regexes[method] = []
maxgroups = 99
for x in range(0, len(all_rules), maxgroups):
some = all_rules[x:x+maxgroups]
combined = (flatpat for (_, flatpat, _, _) in some)
combined = '|'.join('(^%s$)' % flatpat for flatpat in combined)
combined = re.compile(combined).match
rules = [(target, getargs) for (_, _, target, getargs) in some]
comborules.append((combined, rules))
def build(self, _name, *anons, **query):
""" Build an URL by filling the wildcards in a rule. """
builder = self.builder.get(_name)
if not builder:
raise Exception("No route with that name.", _name)
try:
for i, value in enumerate(anons):
query['anon%d' % i] = value
url = ''.join([f(query.pop(n)) if n else f for (n, f) in builder])
return url if not query else url+'?'+parse.urlencode(query)
except KeyError:
raise Exception('Missing URL argument: ')
class CachedProperty(object):
""" A property that is only computed once per instance and then replaces
itself with an ordinary attribute. Deleting the attribute resets the
property. """
def __init__(self, func):
self.__doc__ = getattr(func, '__doc__')
self.func = func
def __get__(self, obj, cls):
if obj is None:
return self
value = obj.__dict__[self.func.__name__] = self.func(obj)
return value
class Route(object):
def __init__(self, app, rule, method, callback, name=None):
self.app = app
self.rule = rule
self.method = method
self.callback = callback
self.name = name or None
def __call__(self, *a, **ka):
return self.call(*a, **ka)
@CachedProperty
def call(self):
return self.callback
class Response(object):
def __init__(self, status_code=None, body=''):
self.body = body
self.status = status_code or '200 OK'
self.response_header = [('Content-Type', 'application/json')]
def content(self):
return [self.body.encode()]
def add_header(self, header):
self.response_header.append(header)
class HttpErrorResponse(Response, Exception):
def __init__(self, status, path, msg):
super().__init__()
self.status = status
self.body = json.dumps({'error_code': status, 'error_request_path': path, 'message': msg})
|
import os
import warnings
import numpy as np
import skopt
import torch
import torchvision
import tabulate
import datasets
from lenet5 import lenet5
from resnet import resnet18
from evaluate import eval_bnn
from sampling import invert_factors
from utils import (accuracy, setup, expected_calibration_error, predictive_entropy, negative_log_likelihood,
get_eigenvectors)
from visualize import hyperparameters
def grid(func, dimensions):
cost = list()
norms, scales = dimensions
for norm in norms:
for scale in scales:
cost.append(func(norm, scale))
return cost
def main():
args = setup()
print("Preparing directories")
filename = f"{args.prefix}{args.model}_{args.data}_{args.estimator}{args.suffix}"
factors_path = os.path.join(args.root_dir, "factors", filename)
weights_path = os.path.join(args.root_dir, "weights", f"{args.model}_{args.data}.pth")
if args.exp_id == -1:
if not args.no_results:
os.makedirs(os.path.join(args.results_dir, args.model, "data", args.estimator, args.optimizer), exist_ok=True)
if args.plot:
os.makedirs(os.path.join(args.results_dir, args.model, "figures", args.estimator, args.optimizer), exist_ok=True)
results_path = os.path.join(args.results_dir, args.model, "data", args.estimator, args.optimizer, filename)
else:
if not args.no_results:
os.makedirs(os.path.join(args.results_dir, args.model, "data", args.estimator, args.optimizer, args.exp_id), exist_ok=True)
if args.plot:
os.makedirs(os.path.join(args.results_dir, args.model, "figures", args.estimator, args.optimizer, args.exp_id), exist_ok=True)
results_path = os.path.join(args.results_dir, args.model, "data", args.estimator, args.optimizer, args.exp_id, filename)
print("Loading model")
if args.model == 'lenet5':
model = lenet5(pretrained=args.data, device=args.device)
elif args.model == 'resnet18' and args.data != 'imagenet':
model = resnet18(pretrained=weights_path, num_classes=43 if args.data == 'gtsrb' else 10, device=args.device)
else:
model_class = getattr(torchvision.models, args.model)
if args.model in ['googlenet', 'inception_v3']:
model = model_class(pretrained=True, aux_logits=False)
else:
model = model_class(pretrained=True)
model.to(args.device).eval()
if args.parallel:
model = torch.nn.parallel.DataParallel(model)
print("Loading data")
if args.data == 'mnist':
val_loader = datasets.mnist(args.torch_data, splits='val')
elif args.data == 'cifar10':
val_loader = datasets.cifar10(args.torch_data, splits='val')
elif args.data == 'gtsrb':
val_loader = datasets.gtsrb(args.data_dir, batch_size=args.batch_size, splits='val')
elif args.data == 'imagenet':
img_size = 224
if args.model in ['googlenet', 'inception_v3']:
img_size = 299
val_loader = datasets.imagenet(args.data_dir, img_size, args.batch_size, args.workers, splits='val',
use_cache=True, pre_cache=True)
print("Loading factors")
if args.estimator in ["diag", "kfac"]:
factors = torch.load(factors_path + '.pth')
elif args.estimator == 'efb':
kfac_factors = torch.load(factors_path.replace("efb", "kfac") + '.pth')
lambdas = torch.load(factors_path + '.pth')
factors = list()
eigvecs = get_eigenvectors(kfac_factors)
for eigvec, lambda_ in zip(eigvecs, lambdas):
factors.append((eigvec[0], eigvec[1], lambda_))
elif args.estimator == 'inf':
factors = torch.load(f"{factors_path}{args.rank}.pth")
torch.backends.cudnn.benchmark = True
norm_min = -10
norm_max = 10
scale_min = -10
scale_max = 10
if args.boundaries:
x0 = list()
boundaries = [[norm_min, scale_min],
[norm_max, scale_max],
[norm_min, scale_max],
[norm_max, scale_min],
[norm_min / 2., scale_min],
[norm_max / 2., scale_max],
[norm_min, scale_max / 2.],
[norm_max, scale_min / 2.],
[norm_min / 2., scale_min / 2.],
[norm_max / 2., scale_max / 2.],
[norm_min / 2., scale_max / 2.],
[norm_max / 2., scale_min / 2.]]
for b in boundaries:
tmp = list()
for _ in range(3 if args.layer else 1):
tmp.extend(b)
x0.append(tmp)
else:
x0 = None
f_norms = np.array([factor.norm().cpu().numpy() for factor in factors])
space = list()
for i in range(3 if args.layer else 1):
space.append(skopt.space.Real(norm_min, norm_max, name=f"norm{i}", prior='uniform'))
space.append(skopt.space.Real(scale_min, scale_max, name=f"scale{i}", prior='uniform'))
stats = {"norms": [], "scales": [], "acc": [], "ece": [], "nll": [], "ent": [], "cost": []}
@skopt.utils.use_named_args(dimensions=space)
def objective(**params):
norms = list()
scales = list()
for f in f_norms:
if args.layer:
# Closest to max
if abs(f_norms.max() - f) < abs(f_norms.min() - f) and abs(f_norms.max() - f) < abs(f_norms.mean() - f):
norms.append(10 ** params['norm0'])
scales.append(10 ** params['scale0'])
# Closest to min
elif abs(f_norms.min() - f) < abs(f_norms.max() - f) and abs(f_norms.min() - f) < abs(f_norms.mean() - f):
norms.append(10 ** params['norm1'])
scales.append(10 ** params['scale1'])
# Closest to mean
else:
norms.append(10 ** params['norm2'])
scales.append(10 ** params['scale2'])
else:
norms.append(10 ** params['norm0'])
scales.append(10 ** params['scale0'])
if args.layer:
print(tabulate.tabulate({'Layer': np.arange(len(factors)),
'F-Norm:': f_norms,
'Norms': norms,
'Scales': scales},
headers='keys', numalign='right'))
else:
print("Norm:", norms[0], "Scale:", scales[0])
try:
inv_factors = invert_factors(factors, norms, args.pre_scale * scales, args.estimator)
except (RuntimeError, np.linalg.LinAlgError):
print(f"Error: Singular matrix")
return 200
predictions, labels, _ = eval_bnn(model, val_loader, inv_factors, args.estimator, args.samples, stats=False,
device=args.device, verbose=False)
err = 100 - accuracy(predictions, labels)
ece = 100 * expected_calibration_error(predictions, labels)[0]
nll = negative_log_likelihood(predictions, labels)
ent = predictive_entropy(predictions, mean=True)
stats["norms"].append(norms)
stats["scales"].append(scales)
stats["acc"].append(100 - err)
stats["ece"].append(ece)
stats["nll"].append(nll)
stats["ent"].append(ent)
stats["cost"].append(err + ece)
print(f"Err.: {err:.2f}% | ECE: {ece:.2f}% | NLL: {nll:.3f} | Ent.: {ent:.3f}")
return err + ece
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=FutureWarning)
if args.optimizer == "gbrt":
res = skopt.gbrt_minimize(func=objective, dimensions=space, n_calls=args.calls, x0=x0, verbose=True,
n_jobs=args.workers, n_random_starts=0 if x0 else 10, acq_func='EI')
# EI (neg. expected improvement)
# LCB (lower confidence bound)
# PI (neg. prob. of improvement): Usually favours exploitation over exploration
# gp_hedge (choose probabilistically between all)
if args.optimizer == "gp":
res = skopt.gp_minimize(func=objective, dimensions=space, n_calls=args.calls, x0=x0, verbose=True,
n_jobs=args.workers, n_random_starts=0 if x0 else 1, acq_func='gp_hedge')
# acq_func: EI (neg. expected improvement), LCB (lower confidence bound), PI (neg. prob. of improvement)
# xi: how much improvement one wants over the previous best values.
# kappa: Importance of variance of predicted values. High: exploration > exploitation
# base_estimator: RF (random forest), ET (extra trees)
elif args.optimizer == "forest":
res = skopt.forest_minimize(func=objective, dimensions=space, n_calls=args.calls, x0=x0, verbose=True,
n_jobs=args.workers, n_random_starts=0 if x0 else 1, acq_func='EI')
elif args.optimizer == "random":
res = skopt.dummy_minimize(func=objective, dimensions=space, n_calls=args.calls, x0=x0, verbose=True)
elif args.optimizer == "grid":
space = [np.arange(norm_min, norm_max + 1, 10), np.arange(scale_min, scale_max + 1, 10)]
res = grid(func=objective, dimensions=space)
print(f"Minimal cost of {min(stats['cost'])} found at:")
if args.layer:
print(tabulate.tabulate({'Layer': np.arange(len(factors)),
'F-Norm:': f_norms,
'Norms': stats['norms'][np.argmin(stats['cost'])],
'Scales': stats['scales'][np.argmin(stats['cost'])]},
headers='keys', numalign='right'))
else:
print("Norm:", stats['norms'][np.argmin(stats['cost'])][0],
"Scale:", stats['scales'][np.argmin(stats['cost'])][0])
if not args.no_results:
print("Saving results")
del res.specs['args']['func']
np.save(results_path + f"_best_params{'_layer.npy' if args.layer else '.npy'}",
[stats['norms'][np.argmin(stats['cost'])],
stats['scales'][np.argmin(stats['cost'])]])
np.save(results_path + f"_hyperopt_stats{'_layer.npy' if args.layer else '.npy'}", stats)
skopt.dump(res, results_path + f"_hyperopt_dump{'_layer.pkl' if args.layer else '.pkl'}")
if args.plot:
print("Plotting results")
hyperparameters(args)
if __name__ == "__main__":
main()
|
import numpy as np
import torch
from torch.autograd import Variable
import cv2
import dlib
from .utils.img_allign_expnet import img_align_modified
from .utils.model_phase2_expnet_CPU import ExpNet_p2
import os
import datetime
import os
os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
class VideoCamera(object):
emo_list = ["neutral", "anger", "contempt", "disgust", "fear", "happy", "sadness", "surprise"]
def __init__(self):
self.cv2 = cv2
self.is_camera_open = True
self.stop_camera = False
self.video = self.cv2.VideoCapture(0)
# Check if camera opened successfully
if not self.video.isOpened():
print("Unable to read camera feed")
self.stop_camera = False
# self.video_file = os.path.join('./static/videos/',
# str(datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%s')) + '.avi')
self.out_file = os.path.join('./static/captured_images/',
str(datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%s')))
if not os.path.exists(self.out_file):
os.makedirs(self.out_file)
self.out_file += "/pic_{}.jpeg"
self.file_ = 0
# frame_width = int(self.video.get(3))
# frame_height = int(self.video.get(4))
# self.video_writer = self.cv2.VideoWriter(self.video_file, self.cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 10,
# (frame_width, frame_height))
self.faceCascade = self.cv2.CascadeClassifier('./static/casscade_model/casscade.xml')
self.model = self.load_model()
self.dlib_detector, self.dlib_predictor = self.load_dlib()
self.font = self.cv2.FONT_HERSHEY_SIMPLEX
self.feelings_faces = []
# append the list with the emoji images
for index, emotion in enumerate(self.emo_list):
self.feelings_faces.append(self.cv2.imread('./static/images/emojis/' + emotion + '.png', -1))
def __del__(self):
self.is_camera_open = False
self.video.release()
# self.video_writer.release()
self.cv2.destroyAllWindows()
def stop(self):
self.is_camera_open = False
self.video.release()
# self.video_writer.release()
self.cv2.destroyAllWindows()
def load_model(self):
model_p2 = ExpNet_p2(useCuda=False, gpuDevice=0)
model_p2.load_state_dict(torch.load(os.path.join('./services/core/model', 'expnet_p2.pt'),
map_location=lambda storage, loc: storage))
return model_p2
def load_dlib(self):
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor("services/core/utils/pretrained_model/shape_predictor_68_face_landmarks.dat")
return detector, predictor
def get_frame(self):
success, image = self.video.read()
if success:
model_image, cropped_image = self.format_image(image)
if model_image is not None:
result, max_val, max_index = self.predict(model_image)
if result is not None:
# write the different emotions and have a bar to indicate probabilities for each class
for index, emotion in enumerate(self.emo_list):
self.cv2.putText(image, emotion, (10, index * 20 + 20), self.font, 0.5, (0, 255, 0), 1)
self.cv2.rectangle(image, (130, index * 20 + 10),
(130 + int(result[index] * 100), (index + 1) * 20 + 4),
(255, 0, 0), -1)
self.cv2.putText(image, self.emo_list[max_index], (10, 360), self.font, 2, (255, 255, 255), 2,
self.cv2.LINE_AA)
face_image = self.feelings_faces[max_index]
for c in range(0, 3):
image[200:320, 10:130, c] = face_image[:, :, c] * (face_image[:, :, 3] / 255.0) + image[200:320,
10:130,
c] * (
1.0 - face_image[:, :, 3] / 255.0)
gray = self.cv2.cvtColor(image, self.cv2.COLOR_BGR2GRAY)
faces = self.faceCascade.detectMultiScale(
gray,
scaleFactor=1.3,
minNeighbors=5,
minSize=(30, 30),
flags=self.cv2.CASCADE_SCALE_IMAGE
)
if len(faces) > 0:
# initialize the first face as having maximum area.
max_area_face = faces[0]
for face in faces: # (x,y,w,h)
if face[2] * face[3] > max_area_face[2] * max_area_face[3]:
max_area_face = face
(x, y, w, h) = max_area_face
image = self.cv2.rectangle(image, (x, y - 50), (x + w, y + h + 10), (255, 0, 0), 2)
self.cv2.imwrite(self.out_file.format(self.file_), image)
self.file_ += 1
# self.video_writer.write(image)
else:
print("No face!!!")
self.stop_camera = False
else:
print("No Emotion Prediction!!!.")
self.stop_camera = False
else:
print("Some issue in image format!!!")
self.stop_camera = False
else:
print("No frame captured from Video!!!")
self.stop_camera = False
try:
return self.cv2.imencode('.jpg', image)[1].tobytes()
except Exception as e:
print("Exception while returning image as byte!!!---> {}".format(e))
self.stop_camera = False
return bytearray()
def format_image(self, image):
try:
image = img_align_modified(image, self.dlib_detector, self.dlib_predictor)
original_img = image
image = self.cv2.cvtColor(image, self.cv2.COLOR_RGB2BGR)
image = self.cv2.resize(image, (96, 96), interpolation=self.cv2.INTER_LINEAR)
image = np.transpose(image, (2, 0, 1))
image = image.astype(np.float32) / 255.0
I = torch.from_numpy(image).unsqueeze(0)
except Exception as e:
print("----->Problem during resize:{}".format(e))
self.stop_camera = True
return None, None
return I, original_img
def predict(self, img):
test_output = self.model(Variable(img))
max_val, idx = torch.max(test_output, 1)
result = test_output.data.cpu().numpy()[0]
result = np.interp(result, (result.min(), result.max()), (0, +1))
return result, max_val, idx.data.cpu().numpy()[0]
|
import os
import pytest
from sqlalchemy import inspect, create_engine
from sqlalchemy.orm import sessionmaker, scoped_session
pytest.TEST_DB_FILEPATH = 'tests/test.db'
@pytest.fixture(scope="session")
def db_engine():
engine_ = create_engine(f"sqlite:///{pytest.TEST_DB_FILEPATH}", echo=True)
yield engine_
engine_.dispose()
os.remove(pytest.TEST_DB_FILEPATH)
@pytest.fixture(scope='module')
def db_session_factory(db_engine):
return scoped_session(sessionmaker(bind=db_engine))
@pytest.fixture(scope='function')
def db_session(db_session_factory):
session_ = db_session_factory()
yield session_
session_.rollback()
session_.close()
@pytest.fixture(scope='function')
def db_inspector(db_engine):
return inspect(db_engine)
@pytest.fixture(autouse=True, scope="function")
def config_db(db_engine):
from src.Part_1 import Base
Base.metadata.drop_all(bind=db_engine)
Base.metadata.create_all(bind=db_engine)
yield
|
import logging
from cdsagent import cfg
LOG = logging.getLogger(__name__)
__author__ = 'Hardy.zheng'
conf = cfg.CONF
class ApiBase(object):
def __init__(self):
pass
class CdsClient(ApiBase):
def __init__(self):
super(CdsClient, self).__init__()
def get_floating_ips(self):
LOG.error('CdsClient:get_floating_ips not implement')
raise NotImplementedError("CdsClient get_floating_ips method \
wasn't implement")
|
#!/usr/bin/env python3
import cv2
import numpy as np
import os
import time
#from matplotlib import pyplot as plt
thisdir = os.getcwd() + "/captures/2020-12-29-02-22-32"
print (thisdir)
img = None
for i in range(1,3132):
image_name = os.path.join(thisdir, 'grayscale_{:d}.pgm'.format(i))
img = cv2.imread(image_name,-1)
if img.any():
height, width = img.shape
if height > 0 and width > 0:
print(image_name)
cv2.imshow('image', img)
cv2.waitKey(20)
cv2.waitKey(0)
cv2.destroyAllWindows() |
"""the_class.py
Temporary name of the file for the class that can be used
to interface with the code generation stuff.
"""
import sympy as sym
from sympy.core.symbol import var
import dendrosym
class DendroGRCodeGen:
"""Class for generating code files for Dendro computations"""
def __init__(self, project_short: str):
# project short is for namespace info, basically like an abbreviation
# for the entire project
self.project_short = project_short.lower()
self.upper_project_short = project_short.upper()
self.var_types = ["VAR"]
self.constraint_vars = []
self.constraint_var_names = []
self.other_vars = []
self.other_var_names = []
self.functions = {}
self.advective_der_var = None
self.parameter_vars = []
pass
def set_advective_der_var(self, in_var):
self.advective_der_var = str(in_var).split("[")[0]
def add_parameter_variables(self, in_vars: list):
# TODO: clean up the parameters
self.parameter_vars += in_vars
def generate_code(self, arc_type="cpu"):
if arc_type == "cpu":
# generate for the CPU
return_str = dendrosym.codegen.generate_cpu(
*self.functions["other"](), "[pp]"
)
pass
elif arc_type == "gpu":
# generate for the GPU
pass
return return_str
def generate_var_enum(self):
# start with the constraints
return_str = ""
return_str += (
dendrosym.codegen.gen_enum_info(
self.constraint_var_names, "VAR_CONSTRAINT", "C"
)
+ "\n"
)
return_str += dendrosym.codegen.gen_enum_info(self.other_var_names, "VAR", "U")
return return_str
def generate_var_name_array(self):
"""Method that generates the var name array"""
return_str = ""
return_str += dendrosym.codegen.gen_var_name_array(
self.constraint_var_names, self.project_short, "C", "CONSTRAINT_VAR"
)
return_str += dendrosym.codegen.gen_var_name_array(
self.other_var_names, self.project_short, "U", "VAR"
)
return return_str
def generate_memory_alloc(self, var_type: str):
"""This generates the memory allocation code
Please note that there needs to be an assigned function
relating to this variable type for this to work
"""
func = self.functions.get(var_type, None)
if func is None:
raise NotImplementedError("Function for this var type not assigned")
# get all of the possible gradient variables as uniques
# TODO: I'm thinking we just save the text file of results
# and then read that in to find the gradient vars
# TODO: fix this!
with open("test1.txt", "r") as fh:
in_text = fh.read()
grad_list = dendrosym.utils.find_derivtype_in_text(in_text, "grad_")
grad2_list = dendrosym.utils.find_derivtype_in_text(in_text, "grad2_")
agrad_list = dendrosym.utils.find_derivtype_in_text(in_text, "agrad_")
return_str = ""
return_str += dendrosym.codegen.generate_deriv_comp(grad_list)
return_str += dendrosym.codegen.generate_deriv_comp(grad2_list)
return_str += dendrosym.codegen.generate_deriv_comp(
agrad_list, self.advective_der_var
)
return return_str
def assign_rhs_function(self, func, var_type: str = "other"):
self.functions[var_type] = func
def generate_rhs_vars(self, var_type: str = "other", zip_var_name="unzipVarsRHS"):
return_str = ""
func = self.functions.get(var_type, None)
if func is None:
raise ValueError("Sorry, but that function hasn't been assigned")
if var_type == "other":
expre, var_names = func()
_, exp_names, _ = dendrosym.codegen.construct_expression_list(
expre, var_names, ""
)
# now I gotta match up the lists to be sure
other_var_names = self.other_var_names.copy()
other_var_names.sort()
other_var_names = list(map(lambda x: x.upper(), other_var_names))
exp_names.sort()
return_str = dendrosym.codegen.gen_var_info(
exp_names,
zip_var_name=zip_var_name,
offset_name="offset",
enum_name="VAR",
enum_prefix="U",
use_const=False,
enum_var_names=other_var_names,
)
else:
raise NotImplementedError("Fix this")
return return_str
def generate_variable_extraction(
self, var_type="other", use_const=False, zip_var_name="uZipVars"
):
return_str = ""
if var_type == "other":
return_str += dendrosym.codegen.gen_var_info(
self.other_var_names,
zip_var_name=zip_var_name,
enum_prefix="U",
use_const=use_const,
)
else:
raise NotImplementedError("Not yet implemented")
return return_str
def generate_phys_constraint_vars(self):
return_str = ""
# start with the physical constraint vars
return_str += dendrosym.codegen.gen_var_info(
self.constraint_var_names,
zip_var_name="uZipConVars",
enum_name="VAR_CONSTRAINT",
enum_prefix="C",
use_const=False,
)
return return_str
def generate_parameter_code(self):
return_str = ""
for param in self.parameter_vars:
return_str += param.generate_cpp_line(
global_param_prefix=self.upper_project_short
)
return_str += "\n"
return return_str
def generate_ko_calculations(
self, var_type="other", ko_sigma_name="sigma", idx="pp"
):
return_str = ""
if var_type == "other":
for var_name in self.other_var_names:
temp_str = f"{var_name}_rhs[{idx}]"
temp_str += f" += {ko_sigma_name} * ("
temp_str += " + ".join(
f"grad_{ii}_{var_name}[{idx}]" for ii in range(3)
)
temp_str += ");\n"
return_str += temp_str
return return_str
def add_var_type(self, var_prefix):
"""Add a variable type to Dendro computations
This method allows you to add another subset of variable type
to be used in the computations. Meaning you can split variables
into different portions based on constraints or something similar.
Note that it will force this to be all caps because this will be
used in global variable definitions.
"""
self.var_types.append(var_prefix)
def add_constraint_var(self, the_var, add_multi=False):
"""Add a single variable to the collection of constraints
This includes variables such as Ham, Mom, Psi4, etc.
"""
if not add_multi:
# make it a list if not incoming
the_var = [the_var]
# iterate through the list
for va in the_var:
if type(va) not in [sym.Symbol, sym.Matrix, tuple]:
raise NotImplementedError("Invalid variable type")
self.constraint_vars.append(va)
self._create_raw_strings_for_vars()
def add_var(self, the_var, add_multi=False):
"""Add a single variable to the collection of variables
This is for variables not considered constraints in the
dendro GR code.
This includes variables such as alpha, chi, k, Gt, beta, Beta,
and others.
"""
if not add_multi:
the_var = [the_var]
for va in the_var:
if type(va) not in [sym.Symbol, sym.Matrix, tuple]:
raise NotImplementedError("Invalid variable type")
self.other_vars.append(va)
self._create_raw_strings_for_vars()
def _create_raw_strings_for_vars(self):
self.constraint_var_names = self.clean_var_names(self.constraint_vars)
self.other_var_names = self.clean_var_names(self.other_vars)
@staticmethod
def clean_var_names(in_vars):
"""Create list of strings for the input variables"""
# first find all strings that correspond to the vars
all_var_names = []
for the_var in in_vars:
if type(the_var) is sym.Matrix:
unique_vars = []
for ii in range(the_var.shape[0]):
for jj in range(the_var.shape[1]):
if str(the_var[ii, jj]) not in unique_vars:
unique_vars.append(str(the_var[ii, jj]))
all_var_names += unique_vars
elif type(the_var) is tuple or type(the_var) is list:
all_var_names += [str(the_name) for the_name in the_var]
elif type(the_var) is sym.Symbol:
all_var_names.append(str(the_var))
else:
raise NotImplementedError("That variable type isn't implemented yet")
# now we clean away potential [idx] information
for ii in range(len(all_var_names)):
curr_var_name = all_var_names[ii]
if "[" in curr_var_name:
curr_var_name = curr_var_name.split("[")[0]
all_var_names[ii] = curr_var_name
return all_var_names
|
import unittest
from pymmbot.coinpit import crypto
class Test(unittest.TestCase):
def test_get_headers(self):
apikey = {
"name" : "18e5f6966c901e78",
"role" : "trade",
"apikey" : "18e5f6966c901e78f5946bfdd798981559e8df0be73d746d90a458779fddc05b",
"userid" : "msupsAQFexFrGpfrxXGSvNUqUwNRRwSc3s",
"secretKey" : "d31448736fcc6945f4482e95055f9ecb898bc3ce166da8121939529101eff1b118e5f6966c901e78f5946bfdd798981559e8df0be73d746d90a458779fddc05b",
"authorization": "HxwFaJHLAqu/KxaOhIe11KXZP2/L6CHFKk5AxLk8vdg0WAQj6EovVGTftd35+gsTgMn/uZJqDf1fK3SGghRYQeU="
}
method = "POST"
body = [
{
"userid" : "msupsAQFexFrGpfrxXGSvNUqUwNRRwSc3s",
"side" : "sell",
"quantity" : 1,
"price" : 1700.8,
"orderType" : "LMT",
"clientid" : "9764b759-53b9-4a71-8591-78cf18dbe616",
"stopPrice" : 15.7,
"crossMargin": False,
"targetPrice": "NONE",
"postOnly" : False,
"instrument" : "MBTCUSD7K090310"
}
]
uri = "/order"
nonce = "1494299047138"
result = "SIGN msupsAQFexFrGpfrxXGSvNUqUwNRRwSc3s.18e5f6966c901e78:4yE0+ECUb5YWNLv5r0DL6/GChi/aATmAk77u+CnDSXg0TYf0gW3L+YZ6Mq3jWuccmGV61vjOAyB+Eya7HDK5DA=="
auth = crypto.get_auth(apikey['userid'], apikey['name'], apikey['secretKey'], nonce, method, uri, body)
self.assertEquals(auth, result)
|
import os
from setuptools import setup
this_directory = os.path.abspath(os.path.dirname(__file__))
with open(os.path.join(this_directory, 'README.md'), encoding='utf-8') as f:
long_description = f.read()
setup(name='photoage',
version='0.1.1',
description='Calculate the age of a photo.',
long_description=long_description,
long_description_content_type='text/markdown',
author='johnlinp',
author_email='johnlinp@gmail.com',
url='https://github.com/johnlinp/photoage',
license='New BSD License',
install_requires=[
'exifread',
],
packages=[
'photoage',
],
scripts=[
'bin/photoage',
],
)
|
from Tkinter import *
v0=Tk()
v0.geometry("242x100")
Label(v0,text="").grid(row=1,column=1)
Label(v0,text="BIENVENIDO AL PROYECTO").grid(row=1,column=2)
Label(v0,text="").grid(row=1,column=3)
Label(v0,text="T E X T O").grid(row=2,column=1)
Label(v0,text="T E X T O").grid(row=2,column=3)
Label(v0,text="T E X T O").grid(row=3,column=1)
Label(v0,text="T E X T O").grid(row=3,column=3)
Label(v0,text="T E X T O").grid(row=4,column=1)
Label(v0,text="T E X T O").grid(row=4,column=3)
Label(v0,text="T E X T O").grid(row=5,column=1)
Label(v0,text="T E X T O").grid(row=5,column=3)
Label(v0,text="T E X T O").grid(row=6,column=1)
Label(v0,text="T E X T O").grid(row=6,column=3)
v0.mainloop()
|
import functools
from behave import step
from acceptance_tests.utilities.fieldwork_helper import fieldwork_create_message_callback, field_work_update_callback
from acceptance_tests.utilities.rabbit_helper import start_listening_to_rabbit_queue
from acceptance_tests.utilities.test_case_helper import test_helper
from config import Config
@step('the action instruction messages for only the HH case are emitted to FWMT where the case has a "{filter_column}" '
'of "{expected_value}"')
@step(
'the action instruction messages are emitted to FWMT where the case has a "{filter_column}" of "{expected_value}"')
def fwmt_messages_received(context, filter_column, expected_value):
_check_emitted_action_instructions(context, filter_column, expected_value, 'false')
@step('the action instruction is emitted to FWMT where case has a "{filter_column}" of "{expected_value}" '
'and CEComplete is "{expected_ce1_complete}"')
def fwmt_message_received_with_ce1_complete(context, filter_column, expected_value, expected_ce1_complete):
_check_emitted_action_instructions(context, filter_column, expected_value, expected_ce1_complete)
def _check_emitted_action_instructions(context, filter_column, treatment_code, expected_ce1_complete):
context.expected_cases_for_action = [
case_created['payload']['collectionCase'] for case_created in context.case_created_events
if case_created['payload']['collectionCase'][filter_column] == treatment_code
]
context.fieldwork_case_ids = [case['id'] for case in context.expected_cases_for_action]
context.expected_ce1_complete = expected_ce1_complete
start_listening_to_rabbit_queue(Config.RABBITMQ_OUTBOUND_FIELD_QUEUE,
functools.partial(fieldwork_create_message_callback, context=context))
test_helper.assertFalse(context.expected_cases_for_action,
msg="Didn't find all expected fieldwork action instruction messages")
@step('a CREATE message is sent to field for each updated case '
'excluding NI CE cases and estab types "TRANSIENT PERSONS" and "MIGRANT WORKERS"')
def fwmt_create_message_sent_for_first_case(context):
context.expected_cases_for_action = [
event['payload']['collectionCase'] for event in context.case_updated_events
if (event['payload']['collectionCase']['address']['estabType'] not in {"TRANSIENT PERSONS", "MIGRANT WORKERS"}
and (event['payload']['collectionCase']['address']['addressType'] != 'CE'
or event['payload']['collectionCase']['address']['region'][0] != 'N'))
]
context.fieldwork_case_ids = [case['id'] for case in context.expected_cases_for_action]
start_listening_to_rabbit_queue(Config.RABBITMQ_OUTBOUND_FIELD_QUEUE,
functools.partial(fieldwork_create_message_callback, context=context))
test_helper.assertFalse(context.expected_cases_for_action,
msg="Didn't find all expected fieldwork action instruction messages")
@step('an UPDATE message is sent to field for each updated case excluding NI CE, "TRANSIENT PERSONS" and refused')
def fwmt_update_message_sent_for_first_case(context):
context.expected_cases_for_action = [
event['payload']['collectionCase'] for event in context.case_updated_events
if (event['payload']['collectionCase']['address']['estabType'] != "TRANSIENT PERSONS"
and (event['payload']['collectionCase']['address']['addressType'] != 'CE'
or event['payload']['collectionCase']['address']['region'][0] != 'N'))
]
context.fieldwork_case_ids = [case['id'] for case in context.expected_cases_for_action]
start_listening_to_rabbit_queue(Config.RABBITMQ_OUTBOUND_FIELD_QUEUE,
functools.partial(field_work_update_callback, context=context))
test_helper.assertFalse(context.expected_cases_for_action,
msg="Didn't find all expected fieldwork action instruction messages")
|
num = int(input('Enter a number: '))
if 100 <= num < 1000:
c = num // 100
r = num % 100
d = r // 10
r = r % 10
if c > 1 and d > 1 and r > 1:
print(f'{num} = {c} hundreds, {d} dozens and {r} units.')
elif c <= 1 and d > 1 and r > 1:
print(f'{num} = {c} hundred, {d} dozens and {r} units.')
elif d <= 1 and c > 1 and r > 1:
print(f'{num} = {c} hundreds, {d} dozen and {r} units.')
elif r <= 1 and c > 1 and d > 1:
print(f'{num} = {c} hundreds, {d} dozens and {r} unit.')
elif c <= 1 and d <= 1 and r > 1:
print(f'{num} = {c} hundred, {d} dozen and {r} units.')
elif d <= 1 and r <= 1 and c < 1:
print(f'{num} = {c} hundreds, {d} dozen and {r} unit.')
elif c <= 1 and r <= 1 and d > 1:
print(f'{num} = {c} hundred, {d} dozens and {r} unity.')
elif c <= 1 and r <= 1 and d <= 1:
print(f'{num} = {c} hundred, {d} dozen and {r} unity.')
elif c > 1 and d <= 1 and r <= 1:
print(f'{num} = {c} hundreds, {d} dozen and {r} unity.')
elif c > 1 and d <= 1 and r <= 1:
print(f'{num} = {c} hundreds, {d} dozen and {r} unity.')
elif c <= 1 and d <= 1 and r <= 1:
print(f'{num} = {c} hundred, {d} dozen and {r} unity.')
elif num < 99:
d = num // 10
u = num % 10
if d > 1 and u > 1:
print(f'{num} = {d} dozens and {u} unitys.')
elif d > 1 and u <= 1:
print(f'{num} = {d} dozens and {u} unity.')
elif d <= 1 and u > 1:
print(f'{num} = {d} dozen and {u} unitys.')
elif d <= 1 and u <= 1:
print(f'{num} = {d} dozen and {u} unity.') |
# Generated by Django 3.0.3 on 2020-02-06 10:24
import django.db.models.deletion
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("example", "0007_artproject_description"),
]
operations = [
migrations.CreateModel(
name="LabResults",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("date", models.DateField()),
("measurements", models.TextField()),
(
"research_project",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
related_name="lab_results",
to="example.ResearchProject",
),
),
],
),
]
|
# import queue
#
# q = queue.Queue()
# q.put(1)
# q.put(2)
# q.put(3)
#
# print(q.get())
# print(q.get())
# print(q.get())
# 生产者消费者
from threading import Thread, current_thread
import time
import random
from queue import Queue
queue = Queue(5)
class ProducerThread(Thread):
def run(self):
name = current_thread().getName()
nums = range(100)
global queue
while True:
num = random.choice(nums)
queue.put(num)
print('生产者 %s 生成了数据 %s' % (name, num))
t = random.randint(1, 3)
time.sleep(t)
print('生产者 %s 睡眠了 %s秒' % (name, t))
class ConsumerThread(Thread):
def run(self):
name = current_thread().getName()
global queue
while True:
num = queue.get()
queue.task_done()
print('消费者 %s 消耗了数据 %s' % (name, num))
t = random.randint(1, 5)
time.sleep(t)
print('消费者 %s 睡眠了 %s 秒' % (name, t))
# 生产者少消费者多的情况
# p1 = ProducerThread(name='p1')
# p1.start()
# c1 = ConsumerThread(name='c1')
# c1.start()
# c2 = ConsumerThread(name='c2')
# c2.start()
# 生产者多消费者少的情况
p1 = ProducerThread(name='p1')
p1.start()
p2 = ProducerThread(name='p2')
p2.start()
p3 = ProducerThread(name='p3')
p3.start()
c1 = ConsumerThread(name='c1')
c1.start()
|
import unittest
import game_of_chess
class TestPart1(unittest.TestCase):
"""
--- Day 5: How About a Nice Game of Chess? ---
You are faced with a security door designed by Easter Bunny engineers
that seem to have acquired most of their security knowledge by watching
hacking movies.
The eight-character password for the door is generated one character at a
time by finding the MD5 hash of some Door ID (your puzzle input) and an
increasing integer index (starting with 0).
A hash indicates the next character in the password if its hexadecimal
representation starts with five zeroes. If it does, the sixth character
in the hash is the next character of the password.
For example, if the Door ID is abc:
- The first index which produces a hash that starts with five zeroes is
3231929, which we find by hashing abc3231929; the sixth character of
the hash, and thus the first character of the password, is 1.
- 5017308 produces the next interesting hash, which starts with
000008f82..., so the second character of the password is 8.
- The third time a hash starts with five zeroes is for abc5278568,
discovering the character f.
In this example, after continuing this search a total of eight times, the
password is 18f47a30.
Given the actual Door ID, what is the password?
"""
@unittest.skip('Very long test')
def test_password(self):
password = game_of_chess.first_algorithm('abc')
self.assertEqual('18f47a30', password)
self.assertEqual(8, len(password))
@unittest.skip('Very long test')
def test_puzzle_input(self):
password = game_of_chess.first_algorithm('abbhdwsy')
self.assertEqual('801b56a7', password)
class TestPart2(unittest.TestCase):
"""
--- Part Two ---
As the door slides open, you are presented with a second door that uses a
slightly more inspired security mechanism. Clearly unimpressed by the
last version (in what movie is the password decrypted in order?!), the
Easter Bunny engineers have worked out a better solution.
Instead of simply filling in the password from left to right, the hash
now also indicates the position within the password to fill. You still
look for hashes that begin with five zeroes; however, now, the sixth
character represents the position (0-7), and the seventh character is the
character to put in that position.
A hash result of 000001f means that f is the second character in the
password. Use only the first result for each position, and ignore invalid
positions.
For example, if the Door ID is abc:
- The first interesting hash is from abc3231929, which produces
0000015...; so, 5 goes in position 1: _5______.
- In the previous method, 5017308 produced an interesting hash;
however, it is ignored, because it specifies an invalid position (8).
- The second interesting hash is at index 5357525, which produces
000004e...; so, e goes in position 4: _5__e___.
You almost choke on your popcorn as the final character falls into place,
producing the password 05ace8e3.
Given the actual Door ID and this new method, what is the password? Be
extra proud of your solution if it uses a cinematic "decrypting"
animation.
"""
@unittest.skip('Very long test')
def test_password(self):
password = game_of_chess.second_algorithm('abc')
self.assertEqual('05ace8e3', password)
@unittest.skip('Very long test')
def test_puzzle_input(self):
password = game_of_chess.second_algorithm('abbhdwsy')
self.assertEqual('424a0197', password)
|
from django.db import models
# Create your models here.
from apps.user.models import User
# faved_books
class Book(models.Model):
title = models.CharField(max_length=45)
favs = models.ManyToManyField(User, related_name="faved_books")
|
from django.shortcuts import render, redirect, reverse
from .models import Product
from accounts.models import UserProfile
"""
View for all products
"""
def all_products(request):
# Make sure pro version product not added again
added = False
cart = request.session.get('cart')
# If item in cart mark added to true
if cart:
added = True
# Get user info from UserProfile Model
user_info = UserProfile.objects.filter(user=request.user)
for u in user_info:
account = u.account
# Get all Products
products = Product.objects.all()
return render(request, "products.html", {
"products": products,
"account": account,
"added": added
}) |
# Typy zmiennych:
a = 5 #liczba całkowita (int)
b = 4.3 #liczba zmiannoprzecinkowa (float)
imie = 'Wojciech' #ciąg znaków (string)
mleko = True #true or false (bool) |
from odoo import api, fields, models,exceptions
import logging
_logger = logging.getLogger(__name__)
class ResPartner(models.Model):
_inherit = "res.partner"
# Change the display name when user select partner
# def name_get(self):
# res = []
# for field in self:
# if field.ref:
# res.append((field.id, '%s %s' % (field.ref, field.name)))
# else:
# res.append((field.id, '%s %s' % ('', field.name)))
#
# return res
#@api.depends('is_company', 'name', 'parent_id.name', 'type', 'company_name', 'ref')
# def _compute_display_name(self):
# diff = dict(show_address=None, show_address_only=None, show_email=None, html_format=None, show_vat=False)
# names = dict(self.with_context(**diff).name_get())
# for partner in self:
# if partner.ref and len(partner.ref) > 0:
# name = names.get(partner.id)
# new_name = name.replace(partner.ref, '')
# partner.display_name = new_name.strip()
# else:
# partner.display_name = names.get(partner.id)
# by default, contact person will also be the customer/vendor (depending on their company)
# @api.multi
# def _get_default_is_customer(self):
# for contact in self:
# if contact.type == 'delivery' or contact.type == 'other' or contact.type == 'private':
# return False
# elif contact.is_company is False:
# return False
# else:
# return True
#
# customer = fields.Boolean(string='Is a Customer', default=_get_default_is_customer,
# help="Check this box if this contact is a customer.")
#
# @api.multi
# def _get_default_is_vendor(self):
# for contact in self:
# if contact.type == 'delivery' or contact.type == 'other' or contact.type == 'private':
# return False
# elif contact.is_company is False:
# return False
# else:
# return True
#
# supplier = fields.Boolean(string='Is a Vendor', default=_get_default_is_vendor,
# help="Check this box if this contact is a customer.")
@api.model
def create(self, vals):
if vals.get('company_type') == 'person' or vals.get('is_company'):
vals['customer'] = False
vals['supplier'] = False
res = super(ResPartner, self).create(vals)
return res
@api.multi
def write(self, vals):
if self.company_type == 'person' and self.parent_id:
vals['customer'] = False
vals['supplier'] = False
res = super(ResPartner, self).write(vals)
return res |
"""
title: helloWorld
author: mfp4311
date: 6/25/19 2:08 PM
"""
print("Elizabeth,", end=" ")
print("Emily,", end=" ")
print("Bob,", end=" ")
print("Antonio")
print("\t\t\t\t\t|||")
print("\t\t\t\t\t O")
print("\t\t\t\t / \ ")
print("\t\t\t\t\t| |") |
from django.contrib import admin
# Register your models here.
from .models import Bb
from .models import Rubric
class BbAbmin(admin.ModelAdmin):
list_display = ('title', 'content','price','published','rubric','img','image_img')
list_display_links = ('title','content','img','image_img')
search_fields = ('title','content',)
readonly_fields = ['image_img', ]
admin.site.register(Bb,BbAbmin)
admin.site.register(Rubric)
|
from unittest.mock import patch
import pytest
from linnapi import exceptions, inventory
from linnapi.requests.inventory import GetStockItemIDsBySKU
@pytest.fixture
def sku():
return "E32-99X-8G2"
@pytest.fixture
def stock_item_id():
return "965c4c47-227d-4b87-913f-0114dab13b61"
@pytest.fixture
def skus():
return ["aaa", "bbb", "ccc"]
@pytest.fixture
def stock_item_ids():
return [
"d28efd06-57c4-4792-9048-50c31264acd3",
"69a73aa0-f504-4f9a-ae59-13f6aae38279",
"4a692c35-ef6c-4fde-9387-69a52625c7e6",
]
@pytest.fixture
def response_data(sku, stock_item_id):
return {
"Items": [
{
"StockItemId": stock_item_id,
"SKU": sku,
}
]
}
@pytest.fixture
def multiple_response_data(skus, stock_item_ids):
return {
"Items": [
{
"StockItemId": stock_item_id,
"SKU": sku,
}
for sku, stock_item_id in zip(skus, stock_item_ids)
]
}
@pytest.fixture
def mock_single_response(response_data):
with patch("linnapi.inventory.make_request") as mock_make_request:
mock_make_request.return_value = response_data
yield mock_make_request
@pytest.fixture
def mock_multiple_response(multiple_response_data):
with patch("linnapi.inventory.make_request") as mock_make_request:
mock_make_request.return_value = multiple_response_data
yield mock_make_request
@pytest.fixture
def mock_invalid_response():
with patch("linnapi.inventory.make_request") as mock_make_request:
mock_make_request.return_value = {"invalid_key": "invalid_value"}
yield mock_make_request
def test_get_stock_item_ids_by_sku_return_value(
mock_single_response, sku, stock_item_id
):
returned_value = inventory.get_stock_item_ids_by_sku([sku])
assert returned_value == {sku: stock_item_id}
def test_get_stock_item_ids_by_sku_makes_request(mock_single_response, sku):
inventory.get_stock_item_ids_by_sku([sku])
assert mock_single_response.called_once_with(GetStockItemIDsBySKU, skus=[sku])
def test_get_stock_item_ids_by_sku_makes_request_with_multiple_skus(
mock_multiple_response, skus
):
inventory.get_stock_item_ids_by_sku(skus)
assert mock_multiple_response.called_once_with(GetStockItemIDsBySKU, skus=skus)
def test_get_stock_item_ids_by_sku_return_value_multiple_skus(
mock_multiple_response, skus, stock_item_ids
):
returned_value = inventory.get_stock_item_ids_by_sku([sku])
assert returned_value == {
sku: stock_item_id for sku, stock_item_id in zip(skus, stock_item_ids)
}
def test_get_stock_item_ids_by_sku_invalid_response(mock_invalid_response, sku):
with pytest.raises(exceptions.InvalidResponseError):
inventory.get_stock_item_ids_by_sku(sku)
|
height = int(input('Введите рост в сантиметрах: '))
mas = int(input('Введите массу в килограммах: '))
#перевод роста с сантиметров в метры
height_m = height/100
#вычисление индекса массы тела
index= mas/(height_m*height_m)
#вывод индекса массы тела
print('Индекс массы тела: ' + str(index))
#Интерпретирование показателя индекса массы тела и вывод показателя
if index<=16:
print('Выраженный дефицит массы тела')
elif (index>16) and (index<=18.5):
print('Недостаточная масса тела (дефицит)')
elif (index>18.5) and (index<=25):
print('Нормальная масса тела')
elif (index>25) and (index<=30):
print('Избыточная масса тела (предожирение)')
else:
print("Обратите внимание на питание, у Вас ожирение:")
if (index>30) and (index<=35):
print('I степени')
elif (index > 35) and (index <= 40):
print('II степени')
else:
print('III степени')
|
def check(number):
answer = number % 2
return answer
number = int(input("enter a number: "))
if check(number) == 0:
print(number, "is even")
else:
print(number, "is odd")
|
def pytest_configure():
from django.conf import settings
settings.configure(
DEBUG_PROPAGATE_EXCEPTIONS=True,
DATABASES={'default': {'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:'}},
SITE_ID=1,
SECRET_KEY='not very secret in tests',
USE_I18N=True,
USE_L10N=True,
STATIC_URL='/static/',
ROOT_URLCONF='tests.urls',
TEMPLATES=[
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
],
MIDDLEWARE_CLASSES=(
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
),
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.messages',
'django.contrib.staticfiles',
'rest_framework_simplejwt.token_blacklist',
'tests',
'auth_backend.role',
'auth_backend.permission',
'auth_backend.user',
),
PASSWORD_HASHERS=(
'django.contrib.auth.hashers.SHA1PasswordHasher',
'django.contrib.auth.hashers.PBKDF2PasswordHasher',
'django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher',
'django.contrib.auth.hashers.BCryptPasswordHasher',
'django.contrib.auth.hashers.MD5PasswordHasher',
'django.contrib.auth.hashers.CryptPasswordHasher',
),
AUTH_USER_MODEL='tests.TestUser',
AUTHENTICATION_BACKENDS=['django.contrib.auth.backends.AllowAllUsersModelBackend'], # noqa: E501
AUTH_PASSWORD_VALIDATORS=[
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator', # noqa: E501
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator', # noqa: E501
'OPTIONS': {
'min_length': 10,
}
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator', # noqa: E501
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator', # noqa: E501
},
],
REST_FRAMEWORK={
'DEFAULT_PERMISSION_CLASSES': (
'rest_framework.permissions.IsAuthenticated',
'auth_backend.permission.permissions.HasRolePermission',
),
},
PROJECT_NAME="Company name",
FROM_EMAIL="support@example.com",
)
try:
import django
django.setup()
except AttributeError:
pass
|
from django.contrib.auth.models import User
from model_mommy.recipe import Recipe
from documents.models import Document
from interface.models import Repo
document = Recipe(Document)
repo = Recipe(Repo)
user = Recipe(User)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def dark_start(target):
from dark_core.database.mysqlManger import sqlMg
from hiddenDetect import hiddenlink_obj
from dark_core.output.console import consoleLog
from dark_core.output.textFile import fileLog
from dark_core.output.logging import logger
from dark_core.profile.profile import pf
from dark_core.settings.settings import settings
from dark_core.parser.urlParser import url_object
from datetime import datetime
# 设置日志模块
if pf.getLogType() == 'True':
file_path = settings.get('LOG_FILE_PATH')
datetimestrf = datetime.now().strftime('%Y-%m-%d')
domain = url_object(target).getRootDomain # 获取当前页面的根域名
file_name = file_path + domain + '_' + datetimestrf + '.log'# 检测文件名按域名_时间.log的形式加载
fileLog.set_file_name(file_name) # 设置日志文件名
logger.setOutputPlugin(fileLog)
else:
logger.setOutputPlugin(consoleLog)
# 执行检测
hidden = hiddenlink_obj(target)
hidden.init()
hidden.run()
hidden.finsh()
# 关闭相关数据库的连接和日志打印模块
sqlMg.dispose()
logger.endLogging()
if __name__ == '__main__':
url = 'http://www.baidu.com'
dark_start(url)
|
from splinter import Browser
from bs4 import BeautifulSoup
import pandas as pd
from selenium import webdriver
def init_browser():
executable_path = {'executable_path': 'chromedriver.exe'}
return Browser('chrome', **executable_path, headless=False)
def scrape():
browser = init_browser()
url = 'https://mars.nasa.gov/news/'
browser.visit(url)
html = browser.html
soup = BeautifulSoup(html, 'html.parser')
news_title = soup.find("div", class_="content_title").text
news_p = soup.find("div", class_="article_teaser_body").text
url = 'https://www.jpl.nasa.gov/spaceimages/?search=&category=Mars'
browser.visit(url)
html = browser.html
soup = BeautifulSoup(html, 'html.parser')
featured_image_url_raw = soup.find("article", class_="carousel_item")["style"][23:75]
featured_image_url = "https://www.jpl.nasa.gov" + featured_image_url_raw
url = 'https://twitter.com/marswxreport?lang=en'
browser.visit(url)
html = browser.html
soup = BeautifulSoup(html, 'html.parser')
mars_weather = soup.find("p", class_="TweetTextSize TweetTextSize--normal js-tweet-text tweet-text").text
url = 'http://space-facts.com/mars/'
tables = pd.read_html(url)
df = tables[0]
df.columns = ['Description', 'Values']
df = df.set_index('Description')
html_table = df.to_html()
html_table = html_table.replace('\n', '')
url = 'https://astrogeology.usgs.gov/search/results?q=hemisphere+enhanced&k1=target&v1=Mars'
browser.visit(url)
html = browser.html
soup = BeautifulSoup(html, 'html.parser')
results = soup.find_all("div", class_="description")
hemisphere_image_urls = []
for result in results:
dic = {}
browser = webdriver.Chrome("C:/Users/alexb/LearnPython/web_scraping/chromedriver.exe")
url = 'https://astrogeology.usgs.gov/search/results?q=hemisphere+enhanced&k1=target&v1=Mars'
browser.get(url)
click = result.h3.text
browser.find_element_by_link_text(click).click()
soup_level2=BeautifulSoup(browser.page_source, 'lxml')
img_url = soup_level2.find("div", class_="downloads").a["href"]
title = soup_level2.find("h2", class_="title").text
title = title.split(" ")
title = title[:-1]
title = ' '.join(title)
dic['title'] = title
dic['img_url'] = img_url
hemisphere_image_urls.append(dic)
mars_dic = {
"news_title": news_title,
"news_p": news_p,
"featured_image_url": featured_image_url,
"mars_weather": mars_weather,
"html_table": html_table,
"mars_facts": hemisphere_image_urls
}
return mars_dic
|
import asyncio
from config import DISCOVERY_PORT, HOST, MESSAGE_PORT
from handlers.discovery_handler import handle_discovery_request
from handlers.message_handler import handle_message
from controller import interact
loop = asyncio.get_event_loop()
discovery_job = asyncio.start_server(handle_discovery_request, HOST, DISCOVERY_PORT, loop=loop)
discovery_server = loop.run_until_complete(discovery_job)
message_job = asyncio.start_server(handle_message, HOST, MESSAGE_PORT, loop=loop)
message_server = loop.run_until_complete(message_job)
loop.run_until_complete(interact(loop))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
discovery_server.close()
message_server.close()
loop.run_until_complete(discovery_server.wait_closed())
loop.run_until_complete(message_server.wait_closed())
loop.close()
|
from tkinter import *
root = Tk()
x = 0
def increase():
global x
x += 1
label.configure(text=x)
def decrease():
global x
x -= 1
label.configure(text=x)
label = Label(text=x)
sendbutton = Button(text="increase", command=increase)
deletebutton = Button(text="decrease", command=decrease)
sendbutton.grid()
label.grid()
deletebutton.grid()
mainloop() |
"""
for elemento in interável:
faça algo
Para cada 'elemento' dentro da 'interável':
faça algo
"""
palavra = 'python'
for posição, letra in enumerate(palavra):
print(posição, letra) |
print("Welcome to the tip calculator.")
bill = float(input("What was the total bill? $"))
tip = float(input("What percentage tip would you like to give? 10, 12, or 15? "))
person = int(input("how many people to split the bill? "))
result = float(bill * ( 1 + (tip / 100 ) ) / person)
totalbill = float(round(result,2))
print(f"Each person should pay ${totalbill} ") |
import markdown
from flask import abort, flash, redirect, render_template, request
from flask_babel import gettext as _
from flask_login import current_user, login_required
from ..ext import db
from ..forms.base import DeleteForm
from ..models import Brew, TastingNote
from ..utils.pagination import get_page
from ..utils.views import next_redirect
from . import tasting_bp
from .forms import TastingNoteForm
from .permissions import AccessManager
from .utils import TastingUtils
@tasting_bp.route('/all', endpoint='all')
def all_tasting_notes():
page_size = 20
page = get_page(request)
kw = {}
if current_user.is_authenticated:
kw['extra_user'] = current_user
query = TastingUtils.notes(public_only=True, **kw)
query = query.order_by(db.desc(TastingNote.date))
pagination = query.paginate(page, page_size)
context = {
'public_only': True,
'pagination': pagination,
}
return render_template('tasting/list.html', **context)
@tasting_bp.route('/<int:brew_id>/add', methods=['GET', 'POST'], endpoint='add')
@login_required
def brew_add_tasting_note(brew_id):
brew = Brew.query.get_or_404(brew_id)
AccessManager.check_create(brew)
form = TastingNoteForm()
if form.validate_on_submit():
form.save(brew)
flash(_('tasting note for %(brew)s saved', brew=brew.name), category='success')
next_ = next_redirect('brew.details', brew_id=brew.id)
return redirect(next_)
ctx = {
'brew': brew,
'form': form,
}
return render_template('tasting/tasting_note.html', **ctx)
@tasting_bp.route('/<int:note_id>/delete', methods=['GET', 'POST'], endpoint='delete')
@login_required
def brew_delete_tasting_note(note_id):
note = TastingNote.query.get_or_404(note_id)
brew = note.brew
AccessManager(note, None).check()
form = DeleteForm()
if form.validate_on_submit() and form.delete_it.data:
db.session.delete(note)
db.session.commit()
flash(
_('tasting note for brew %(brew)s has been deleted', brew=brew.name),
category='success'
)
next_ = next_redirect('brew.details', brew_id=brew.id)
return redirect(next_)
ctx = {
'brew': brew,
'note': note,
'delete_form': form,
}
return render_template('tasting/tasting_note_delete.html', **ctx)
@tasting_bp.route('/ajaxtext', endpoint='loadtext')
def brew_load_tasting_note_text():
provided_id = request.args.get('id')
if not provided_id:
abort(400)
note_id = provided_id.rsplit('_', 1)[-1]
note = TastingNote.query.get_or_404(note_id)
return note.text
@tasting_bp.route('/ajaxupdate', methods=['POST'], endpoint='update')
@login_required
def brew_update_tasting_note():
note_id = request.form.get('pk')
if not note_id:
abort(400)
note = TastingNote.query.get_or_404(note_id)
AccessManager(note, None).check()
value = request.form.get('value', '').strip()
if value:
note.text = value
db.session.add(note)
db.session.commit()
return markdown.markdown(value)
return note.text_html
|
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(-10,10)
y = x**2
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(x,y)
coords = []
def onclick(event):
global ix, iy
ix, iy = event.xdata, event.ydata
print ('x = %d, y = %d'%(ix, iy))
global coords
coords.append((ix, iy))
if len(coords) == 2:
fig.canvas.mpl_disconnect(cid)
return coords
cid = fig.canvas.mpl_connect('button_press_event', onclick)
#Here is a simple example that prints the location of the mouse click and which button was pressed:
fig, ax = plt.subplots()
ax.plot(np.random.rand(10))
def onclick(event):
print('%s click: button=%d, x=%d, y=%d, xdata=%f, ydata=%f' %
('double' if event.dblclick else 'single', event.button,
event.x, event.y, event.xdata, event.ydata))
cid = fig.canvas.mpl_connect('button_press_event', onclick) |
__version__ = '0.0.8'
# 0.0.8 - Multiple major changes
# - Finding label errors is no fully parallelized.
# - prune_count_method parameter has been removed.
# - estimate_confident_joint_from_probabilities now automatically calibrates confident joint to be a true joint estimate.
# - Confident joint algorithm changed! When an example is found confidently as 2+ labels, choose class with max probability.
# 0.0.7 - Massive speed increases across the board. Estimating confident joint now nearly instant. NO major API changes.
# 0.0.6 - NO API changes. README updates. Examples added. Tutorials added.
# 0.0.5 - Numerous small bug fixes, but not major API changes. 100% testing code coverage.
# 0.0.4 - FIRST CROSS-PLATFORM WORKING VERSION OF CLEANLAB. Adding test support.
# 0.0.3 - Adding working logo to README, pypi working
# 0.0.2 - Added logo to README, but link does not load on pypi
# 0.0.1 - initial commit
|
import tweepy
consumer_key = "kJw5DKyNxQUUgaT5trGZX09a4"
consumer_secret = "HiLwij1CAMB4R618sQ7zFs7mDpEaKkoVaDXpNaN7FjFoGqiDK4"
access_token = "1092953497392242688-dX4PP4DyMtVihRUNnURKnJGTDYaUfk"
access_token_secret = "v8sgivQiAqHv5FRPsupb5YfJTicft35SoxOA6mLozSwJy"
# Creating the authentication object
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
# Setting your access token and secret
auth.set_access_token(access_token, access_token_secret)
# Creating the API object while passing in auth information
api = tweepy.API(auth)
public_tweets = api.home_timeline()
# foreach through all tweets pulled
for tweet in public_tweets:
# printing the text stored inside the tweet object
print tweet.text
print tweet.created_at
print tweet.user.screen_name
print tweet.user.location
|
@app.route("/user/<username>", methods=["GET"])
@my_profiler
def route_one():
api_live = ping_api()
if not api_live:
return make_response('', 503)
return make_response('', 200)
@app.route("/login/0000")
@my_profiler
def route_two():
api_live = ping_api()
if not api_live:
return make_response('', 503)
return make_response('', 200) |
# Copyright (C) 2021 by Kevin D. Woerner
##-# =KDW= ################# BUILDER $KWROOT/0lib/vkkcp.sh ##################
##-# =KDW= ############# SOURCE $KWROOT/codekdw/kw-lib/Kw.fwipp #############
##-# =KDW= #### THIS FILE CAN BE OVERWRITTEN BY KEVIN D. WOERNER OR HIS #####
##-# =KDW= ############ MINIONS AT *ANY* TIME. Caveat utilitor. #############
# 2021-05-14 kdw For Changelog, See File varylog
import sys
import math
import time
KILOGRAM = 1.0
METER = 1.0
SECOND = 1.0
KELVIN = 1.0
AMPERE = 1.0
MOLE = 1.0
CANDELA = 1.0
BIT = 1.0
RADIAN = 1.0
MASS = KILOGRAM
LENGTH = METER
DISTANCE = LENGTH
TEMPERATURE = KELVIN
TIME = SECOND
ANGLE = RADIAN
AMOUNT = MOLE
CURRENT = AMPERE
CHARGE = AMPERE * SECOND
COULOMB = AMPERE * SECOND
STERADIAN = (RADIAN * RADIAN)
METRE = METER
KG = KILOGRAM
RAD = RADIAN
E = math.exp(1.0)
TAU = 8.0 * math.atan2(1.0, 1.0) / RAD
PHI = 0.5 + math.sqrt(5.0) / 2.0
TWOLN = math.log(2.0)
TENLN = math.log(10.0)
TWOSQRT = math.sqrt(2.0)
EULER = 0.577215664901532860606512090082402431042159335939924
FEIGENBAUM = 4.669201609102990671853203820466201617258185577475769
APERY = 1.202056903159594285399738161511449990764986292340499
GAMMAMIN = 1.461632144968362341262659542325721328468196204006446
PI = TAU / 2.0
YOTTA = 1.0E+24
ZETTA = 1.0E+21
EXA = 1.0E+18
PETA = 1.0E+15
TERA = 1.0E+12
GIGA = 1.0E+9
MEGA = 1.0E+6
KILO = 1.0E+3
HECTO = 1.0E+2
DECA = 1.0E+1
DECI = 1.0E-1
CENTI = 1.0E-2
MILLI = 1.0E-3
MICRO = 1.0E-6
NANO = 1.0E-9
PICO = 1.0E-12
FEMTO = 1.0E-15
ATTO = 1.0E-18
ZEPTO = 1.0E-21
YOCTO = 1.0E-24
KIBI = 1024.0
MEBI = KIBI * KIBI
GIBI = MEBI * KIBI
TEBI = GIBI * KIBI
PEBI = TEBI * KIBI
EXBI = PEBI * KIBI
ZEBI = EXBI * KIBI
YOBI = ZEBI * KIBI
MPS = METER / SECOND
MPSS = METER / (SECOND * (SECOND))
UNITGM = METER * (MPS * (MPS))
NEWTON = KILOGRAM * MPSS
JOULE = NEWTON * METER
PA = NEWTON / (METER * (METER))
WATT = JOULE / SECOND
HERTZ = 1.0 / SECOND
Hz = HERTZ
AMP = AMPERE
VOLT = WATT / AMPERE
OHM = VOLT / AMPERE
HENRY = OHM * SECOND
FARAD = COULOMB / VOLT
SIEMENS = 1.0 / OHM
WEBER = VOLT * SECOND
TESLA = WEBER / (METER * (METER))
LUMEN = CANDELA * STERADIAN
LUX = LUMEN / (METER * (METER))
BOLTZMANN = 1.380649E-23 * JOULE / KELVIN
BOLTZMANN_ERR = 0.0
BOLTZMANN_REC = 1.0 / BOLTZMANN
BOLTZMANN_REC_ERR = 0.0
ELEMENTARYCHARGE = 1.602176634E-19 * COULOMB
ELEMENTARYCHARGE_ERR = 0.0
LIGHT = 2.99792458E+8 * METER / SECOND
LIGHT_ERR = 0.0
LIGHT_REC = 1.0 / LIGHT
LIGHT_REC_ERR = 0.0
AVOGADRO = 6.02214076E+23 / MOLE
AVOGADRO_ERR = 0.0
AVOGADRO_REC = 1.0 / AVOGADRO
AVOGADRO_REC_ERR = 0.0
PLANCK = 6.62607015E-34 * JOULE * SECOND
PLANCK_ERR = 0.0
PLANCK_REC = 1.0 / PLANCK
PLANCK_REC_ERR = 0.0
KCD = 6.83E+2 * LUMEN / WATT
KCD_ERR = 0.0
dvCs_Hz = 9.19263177E+9 / SECOND
dvCs_WAVELENGTH = LIGHT / dvCs_Hz
dvCs_ENERGY = dvCs_Hz * PLANCK
dvCs_ERR = 0.0
kB = BOLTZMANN
kB_ERR = BOLTZMANN_ERR
kB_REC = 1.0 / kB
kB_REC_ERR = BOLTZMANN_ERR
ELECTRON_CHARGE = - ELEMENTARYCHARGE
ELECTRON_CHARGE_ERR = ELEMENTARYCHARGE_ERR
PLANCKBAR = PLANCK / TAU
PLANCKBAR_ERR = PLANCK_ERR
h = PLANCK
h_ERR = PLANCK_ERR
h_REC = 1.0 / PLANCK
h_REC_ERR = PLANCK_ERR
c = LIGHT
c_ERR = LIGHT_ERR
c_REC = 1.0 / LIGHT
c_REC_ERR = LIGHT_ERR
HBAR = PLANCKBAR
HBAR_ERR = PLANCKBAR_ERR
GRAVITY = 9.80665 * MPSS
GRAVITY_ERR = 0.0
ATMOSPHERE = 1.01325E+5 * PA
ATMOSPHERE_ERR = 0.0
AU = 1.495978707E+11 * METER
AU_ERR = 0.0
JOSEPHSON = 2.0 * ELEMENTARYCHARGE / PLANCK
JOSEPHSON_ERR = 0.0
VONKLITZING = PLANCK / (ELEMENTARYCHARGE * (ELEMENTARYCHARGE))
VONKLITZING_ERR = 0.0
FARADAY = ELEMENTARYCHARGE * AVOGADRO
FARADAY_ERR = 0.0
FARADAY_REC = 1.0 / FARADAY
FARADAY_REC_ERR = 0.0
GAS = BOLTZMANN * AVOGADRO
GAS_ERR = 0.0
GAS_REC = 1.0 / GAS
GAS_REC_ERR = 0.0
FARADAYCONST = FARADAY
FARADAYCONST_ERR = FARADAY_ERR
FARADAYCONST_REC = 1.0 / FARADAYCONST
FARADAYCONST_REC_ERR = FARADAY_ERR
GASCONST = GAS
GASCONST_ERR = GAS_ERR
GASCONST_REC = 1.0 / GASCONST
GASCONST_REC_ERR = GAS_ERR
GRAVITATION = 6.67430E-11 * UNITGM / KILOGRAM
GRAVITATION_ERR = 2.2E-5
GRAVITATION_REC = 1.0 / GRAVITATION
GRAVITATION_REC_ERR = 2.2E-5
RYDBERG = 1.0973731568160E+7 * LIGHT / METER
RYDBERG_ERR = 1.9E-12
RYDBERG_REC = 1.0 / RYDBERG
RYDBERG_REC_ERR = 1.9E-12
G = GRAVITATION
G_ERR = GRAVITATION_ERR
ALPHA = 1.0 / 137.035999206
ALPHA_ERR = 8.1E-11
ALPHA_REC = 1.0 / ALPHA
ALPHA_REC_ERR = 8.1E-11
ALPHASQRT = math.sqrt(ALPHA)
FLTSIG = 23
FLTMAN = 8
FLTEPS = 1.1920928955078125E-7
FLTMAX = 3.402823466385288598E+38
DBLMAXLN = TWOLN * 1024.0
DBLSIG = 52
DBLMAN = 11
DBLEPS = 2.220446049250313E-16
DBLMAX = 1.79769313486227E+308
SI16MAX = 32767
SI16MIN = -32768
UI16MAX = 65535
SI32MAX = 2147483647
SI32MIN = -2147483648
UI32MAX = 4294967295
INTMAX = SI32MAX
JEWISH_FIRST_MONTH = 7
MONTHS_IN_YEAR = 12
UVPV = MICRO
MINUTE = 60.0 * SECOND
HOUR = 60.0 * MINUTE
DAY = 24.0 * HOUR
WEEK = 7.0 * DAY
FLICK = SECOND / 705600000.0
JDAY = DAY
JYEAR = 365.25 * JDAY
JCENTURY = 100.0 * JYEAR
GYEAR = 365.2425 * DAY
GYEAR_AT_0J2K = 2000.0
KWT = 0.1875 * SECOND
UET = SECOND
J2K = DAY
J2KDAY = DAY
JDSEC_AT_0GREGORIAN = 1721058.5 * JDAY
JDSEC_AT_0KWT = 2437240.66125 * JDAY
JDSEC_AT_0J2K = 2451545.0 * JDAY
JDSEC_AT_0UET = 2440587.5 * JDAY
TT_AT_0TAI = 32.184 * SECOND
TT_AT_0UT1 = 68.97 * SECOND
GRAM = 0.001 * KILOGRAM
CARAT = 0.2 * GRAM
TONNE = 1000.0 * KILOGRAM
POUND = 0.45359237 * KILOGRAM
LB = POUND
GRAIN = POUND / 7000.0
OUNCE = 0.0625 * POUND
OZ = OUNCE
STONE = 14.0 * POUND
TON = 2000.0 * POUND
MM = MILLI * METER
INCH = 0.0254 * METER
HAND = 4.0 * INCH
FOOT = 12.0 * INCH
SURVEYFOOT = 1200.0 * METER / 3937.0
FEET = FOOT
FT = FOOT
YARD = 3.0 * FEET
HORSE = 8.0 * FEET
LINK = 66.0 * SURVEYFOOT / 100.0
CHAIN = 100 * LINK
FURLONG = 10 * CHAIN
MILE = 5280.0 * FEET
POINT = INCH / 72.0
STANDARDGRAVITY = GRAVITY
GRAVITATIONNASA = 6.67259E-11 * UNITGM / KILOGRAM
GRAVITATIONIERS = 6.67428E-11 * UNITGM / KILOGRAM
KGF = KILOGRAM * GRAVITY
LBF = POUND * GRAVITY
ATM = ATMOSPHERE
STANDARDATMOSPHERE = ATMOSPHERE
TORR = ATMOSPHERE / 760.0
BAR = 1.0E+5 * PA
MMHG = 13595.1 * KILOGRAM * GRAVITY * MM / (METER * (METER) * (METER))
INHG = MMHG * INCH / MM
PSI = POUND * GRAVITY / (INCH * (INCH))
DEGC = KELVIN
DEGF = KELVIN / 1.8
DEGR = DEGF
K_AT_0TEMPC = 273.15 * DEGC
K_AT_0TEMPF = 459.67 * DEGF
K_AT_0TEMPR = 0.0 * DEGR
TEMPF_AT_0TEMPC = 32.0 * KELVIN
MACH = 331.46 * MPS
MPH = MILE / HOUR
HECTARE = 10000.0 * (METER * (METER))
ARE = 100.0 * (METER * (METER))
ACRE = (MILE * (MILE)) / 640.0
BARN = 1.0E-28 * (METER * (METER))
LITER = (METER * (METER) * (METER)) / 1000.0
LITRE = LITER
GALLON = 231.0 * (INCH * (INCH) * (INCH))
QUART = GALLON / 4.0
PINT = QUART / 2.0
CUP = PINT / 2.0
FLOZ = CUP / 8.0
TBLSP = FLOZ / 2.0
TSP = TBLSP / 3.0
BARREL = 42.0 * GALLON
DRYGALLON = 9.25 * 9.25 * PI * (INCH * (INCH) * (INCH))
PECK = 2.0 * DRYGALLON
BUSHEL = 8.0 * DRYGALLON
AH = AMPERE * HOUR
CALORIE = 4.184 * JOULE
CAL_IT = 4.1868 * JOULE
CAL_TH = CALORIE
CAL = CALORIE
BTU_TH = CAL_TH * POUND * DEGF / (GRAM * DEGC)
BTU_IT = CAL_IT * POUND * DEGF / (GRAM * DEGC)
BTU = CALORIE * POUND * DEGF / (GRAM * DEGC)
HP = 550.0 * FOOT * POUND * GRAVITY / SECOND
HORSEPOWER = HP
HPMETRIC = 75.0 * KILOGRAM * GRAVITY * MPS
ELECTRONVOLT = ELEMENTARYCHARGE * VOLT
eV = ELECTRONVOLT
ERG = 1.0E-7 * JOULE
FOE = 1.0E+44 * JOULE
AAABATTERY_CHARGE = 2.1 * AH
AAABATTERY_VOLTAGE = 1.5 * VOLT
AAABATTERY = AAABATTERY_CHARGE * AAABATTERY_VOLTAGE
AAABATTERY_ENERGY = AAABATTERY
AABATTERY_CHARGE = 2.7 * AH
AABATTERY_VOLTAGE = 1.5 * VOLT
AABATTERY = AABATTERY_CHARGE * AABATTERY_VOLTAGE
AABATTERY_ENERGY = AABATTERY
CBATTERY_CHARGE = 8.0 * AH
CBATTERY_VOLTAGE = 1.5 * VOLT
CBATTERY = CBATTERY_CHARGE * CBATTERY_VOLTAGE
CBATTERY_ENERGY = CBATTERY
DBATTERY_CHARGE = 12.0 * AH
DBATTERY_VOLTAGE = 1.5 * VOLT
DBATTERY = DBATTERY_CHARGE * DBATTERY_VOLTAGE
DBATTERY_ENERGY = DBATTERY
NINEVOLT_CHARGE = 0.565 * AH
NINEVOLT_VOLTAGE = 9.0 * VOLT
NINEVOLT = NINEVOLT_CHARGE * NINEVOLT_VOLTAGE
NINEVOLT_ENERGY = NINEVOLT
NINEVOLTBATTERY_CHARGE = NINEVOLT_CHARGE
NINEVOLTBATTERY_VOLTAGE = NINEVOLT_VOLTAGE
NINEVOLTBATTERY = NINEVOLTBATTERY_CHARGE * NINEVOLTBATTERY_VOLTAGE
NINEVOLTBATTERY_ENERGY = NINEVOLTBATTERY
PHONEBATTERY_CHARGE = 3.0 * AH
PHONEBATTERY_VOLTAGE = 3.8 * VOLT
PHONEBATTERY = PHONEBATTERY_CHARGE * PHONEBATTERY_VOLTAGE
PHONEBATTERY_ENERGY = PHONEBATTERY
CARBATTERY_CHARGE = 45.0 * AH
CARBATTERY_VOLTAGE = 12.0 * VOLT
CARBATTERY = CARBATTERY_CHARGE * CARBATTERY_VOLTAGE
CARBATTERY_ENERGY = CARBATTERY
MICROWAVE_Hz = 2.45E+9 * HERTZ
MICROWAVE_WAVELENGTH = LIGHT / MICROWAVE_Hz
MICROWAVE_ENERGY = MICROWAVE_Hz * PLANCK
LF_Hz = 1.0E+5 * HERTZ
LF_WAVELENGTH = LIGHT / LF_Hz
LF_ENERGY = LF_Hz * PLANCK
MF_Hz = 1.0E+6 * HERTZ
MF_WAVELENGTH = LIGHT / MF_Hz
MF_ENERGY = MF_Hz * PLANCK
HF_Hz = 1.0E+7 * HERTZ
HF_WAVELENGTH = LIGHT / HF_Hz
HF_ENERGY = HF_Hz * PLANCK
VHF_Hz = 1.0E+8 * HERTZ
VHF_WAVELENGTH = LIGHT / VHF_Hz
VHF_ENERGY = VHF_Hz * PLANCK
UHF_Hz = 1.0E+9 * HERTZ
UHF_WAVELENGTH = LIGHT / UHF_Hz
UHF_ENERGY = UHF_Hz * PLANCK
SHF_Hz = 1.0E+10 * HERTZ
SHF_WAVELENGTH = LIGHT / SHF_Hz
SHF_ENERGY = SHF_Hz * PLANCK
EHF_Hz = 1.0E+11 * HERTZ
EHF_WAVELENGTH = LIGHT / EHF_Hz
EHF_ENERGY = EHF_Hz * PLANCK
THF_Hz = 1.0E+12 * HERTZ
THF_WAVELENGTH = LIGHT / THF_Hz
THF_ENERGY = THF_Hz * PLANCK
FIR_Hz = 1.0E+12 * HERTZ
FIR_WAVELENGTH = LIGHT / FIR_Hz
FIR_ENERGY = FIR_Hz * PLANCK
MIR_Hz = 1.0E+13 * HERTZ
MIR_WAVELENGTH = LIGHT / MIR_Hz
MIR_ENERGY = MIR_Hz * PLANCK
NIR_Hz = 1.0E+14 * HERTZ
NIR_WAVELENGTH = LIGHT / NIR_Hz
NIR_ENERGY = NIR_Hz * PLANCK
RED_WAVELENGTH = 7.0E-7 * METER
RED_Hz = LIGHT / RED_WAVELENGTH
RED_ENERGY = RED_Hz * PLANCK
ORANGE_WAVELENGTH = 6.2E-7 * METER
ORANGE_Hz = LIGHT / ORANGE_WAVELENGTH
ORANGE_ENERGY = ORANGE_Hz * PLANCK
YELLOW_WAVELENGTH = 5.8E-7 * METER
YELLOW_Hz = LIGHT / YELLOW_WAVELENGTH
YELLOW_ENERGY = YELLOW_Hz * PLANCK
YELLOWGREEN_Hz = 5.4E+14 * HERTZ
YELLOWGREEN_WAVELENGTH = LIGHT / YELLOWGREEN_Hz
YELLOWGREEN_ENERGY = YELLOWGREEN_Hz * PLANCK
GREEN_WAVELENGTH = 5.3E-7 * METER
GREEN_Hz = LIGHT / GREEN_WAVELENGTH
GREEN_ENERGY = GREEN_Hz * PLANCK
BLUE_WAVELENGTH = 5.0E-7 * METER
BLUE_Hz = LIGHT / BLUE_WAVELENGTH
BLUE_ENERGY = BLUE_Hz * PLANCK
VIOLET_WAVELENGTH = 4.2E-7 * METER
VIOLET_Hz = LIGHT / VIOLET_WAVELENGTH
VIOLET_ENERGY = VIOLET_Hz * PLANCK
NUV_Hz = 1.0E+15 * HERTZ
NUV_WAVELENGTH = LIGHT / NUV_Hz
NUV_ENERGY = NUV_Hz * PLANCK
EUV_Hz = 1.0E+16 * HERTZ
EUV_WAVELENGTH = LIGHT / EUV_Hz
EUV_ENERGY = EUV_Hz * PLANCK
UVA_WAVELENGTH = 3.6E-7 * METER
UVA_Hz = LIGHT / UVA_WAVELENGTH
UVA_ENERGY = UVA_Hz * PLANCK
UVB_WAVELENGTH = 3.0E-7 * METER
UVB_Hz = LIGHT / UVB_WAVELENGTH
UVB_ENERGY = UVB_Hz * PLANCK
UVC_WAVELENGTH = 1.9E-7 * METER
UVC_Hz = LIGHT / UVC_WAVELENGTH
UVC_ENERGY = UVC_Hz * PLANCK
SX_Hz = 3.0E+17 * HERTZ
SX_WAVELENGTH = LIGHT / SX_Hz
SX_ENERGY = SX_Hz * PLANCK
SXX_WAVELENGTH = 1.0E-9 * METER
SXX_Hz = LIGHT / SXX_WAVELENGTH
SXX_ENERGY = SXX_Hz * PLANCK
HX_Hz = 1.0E+19 * HERTZ
HX_WAVELENGTH = LIGHT / HX_Hz
HX_ENERGY = HX_Hz * PLANCK
GAMMA_Hz = 1.0E+20 * HERTZ
GAMMA_WAVELENGTH = LIGHT / GAMMA_Hz
GAMMA_ENERGY = GAMMA_Hz * PLANCK
TURN = TAU * RADIAN
ARCTURN = TURN
ARCRADIAN = RADIAN
ARCDEGREE = TURN / 360.0
ARCMINUTE = ARCDEGREE / 60.0
ARCSECOND = ARCMINUTE / 60.0
ARCGRAD = TURN / 400.0
ARCDEG = ARCDEGREE
ARCMIN = ARCMINUTE
ARCSEC = ARCSECOND
GRAD = ARCGRAD
SQUAREDEGREE = (ARCDEGREE * (ARCDEGREE))
SQDEG = SQUAREDEGREE
SPHERESURFACE = 2.0 * TAU * STERADIAN
SHANNON = BIT
NAT = BIT / TWOLN
HARTLEY = TENLN / TWOLN * BIT
HART = HARTLEY
DIT = HARTLEY
BAN = HARTLEY
RPM = TURN / MINUTE
RPS = TURN / SECOND
RPH = TURN / HOUR
OZFIN = OUNCE * GRAVITY * INCH
LBFIN = POUND * GRAVITY * INCH
LBFFT = POUND * GRAVITY * FOOT
KGFM = KG * GRAVITY * METER
Nm_PER_lbfin = LBFIN / (NEWTON * METER)
kgfm_PER_lbfin = LBFIN / (KG * GRAVITY * METER)
lbfinrpm_PER_Hp = HORSEPOWER / (LBFIN * RPM)
ozfin_PER_lbfin = POUND / OUNCE
lbfft_PER_lbfin = INCH / FOOT
W_PER_Hp = HORSEPOWER / WATT
FINESTRUCTURE = ALPHA
FINESTRUCTURE_ERR = ALPHA_ERR
FINESTRUCTURE_REC = 1.0 / FINESTRUCTURE
FINESTRUCTURE_REC_ERR = ALPHA_ERR
MAGNETIC = 2.0 * VONKLITZING * ALPHA / LIGHT
MAGNETIC_ERR = ALPHA_ERR
MU0 = MAGNETIC
MU0_ERR = ALPHA_ERR
ELECTRIC = 1.0 / ((LIGHT * (LIGHT)) * MU0)
ELECTRIC_ERR = ALPHA_ERR
EPSILON0 = ELECTRIC
EPSILON0_ERR = ALPHA_ERR
COULOMBCONST = 1.0 / (2.0 * TAU * ELECTRIC)
COULOMBCONST_ERR = ALPHA_ERR
PROTON_RADIUS = 8.414E-16 * METER
PROTON_RADIUS_ERR = 2.2E-3
MOLARMASS = (1.0 - 3.5E-10) * GRAM / MOLE
MOLARMASS_ERR = 3.0E-10
DALTON = MOLARMASS / AVOGADRO
DALTON_ERR = MOLARMASS_ERR
AMU = DALTON
AMU_ERR = DALTON_ERR
ATOMICMASSUNIT = DALTON
ATOMICMASSUNIT_ERR = DALTON_ERR
UAMU = DALTON
UAMU_ERR = DALTON_ERR
RYDBERG_Hz = RYDBERG
RYDBERG_WAVELENGTH = LIGHT / RYDBERG_Hz
RYDBERG_ENERGY = RYDBERG_Hz * PLANCK
ELECTRON_MASSA = 2.0 * RYDBERG_Hz * PLANCK / ((LIGHT * ALPHA) * (LIGHT *\
ALPHA))
ELECTRON_MASSA_ERR = 2.0 * ALPHA_ERR
HI_Hz = 1.4204057517667E+9 * HERTZ
HI_WAVELENGTH = LIGHT / HI_Hz
HI_ENERGY = HI_Hz * PLANCK
HYDROGENLINE = HI_WAVELENGTH
HYDROGENLINE_ERR = 6.3E-13
HI = LIGHT / HI_Hz
HI_ERR = HYDROGENLINE_ERR
PLANCKMASS = math.sqrt(HBAR * LIGHT / GRAVITATION)
PLANCKCHARGE = ELEMENTARYCHARGE / ALPHASQRT
PLANCKENERGY = PLANCKMASS * (LIGHT * (LIGHT))
PLANCKTEMP = PLANCKENERGY / BOLTZMANN
PLANCKLENGTH = HBAR / (PLANCKMASS * LIGHT)
PLANCKTIME = PLANCKLENGTH / LIGHT
PLANCKFREQUENCY = 1.0 / PLANCKTIME
STEFAN = (TAU * (TAU) * (TAU) * (TAU) * (TAU)) * (BOLTZMANN * (BOLTZMANN)\
* (BOLTZMANN) * (BOLTZMANN)) / (240.0 * (LIGHT * (LIGHT)) *\
(PLANCK * (PLANCK) * (PLANCK)))
STEFAN_ERR = 0.0
PINGPONGBALL_RADIUS = 0.02 * METER
GOLFBALL_RADIUS = 0.02135 * METER
TENNISBALL_RADIUS = 0.03325 * METER
BASEBALL_RADIUS = 9.125 * INCH / TAU
SOFTBALL_RADIUS = 12.0 * INCH / TAU
SOCCERBALL_RADIUS = 0.69 * METER / TAU
BASKETBALL_RADIUS = 0.75 * METER / TAU
PINGPONGBALL_MASS = 0.0027 * KG
GOLFBALL_MASS = 0.04593 * KG
TENNISBALL_MASS = 0.0577 * KG
BASEBALL_MASS = 0.1465 * KG
SOFTBALL_MASS = 0.187 * KG
BASKETBALL_MASS = 0.620 * KG
SOCCERBALL_MASS = 0.430 * KG
MARATHON = 42195.0 * METER
PENNY_HEIGHT = 1.52E-3 * METER
NICKEL_HEIGHT = 1.95E-3 * METER
DIME_HEIGHT = 1.35E-3 * METER
QUARTER_HEIGHT = 1.75E-3 * METER
PENNY_DIAMETER = 0.75 * INCH
NICKEL_DIAMETER = 2.121E-2 * METER
DIME_DIAMETER = 1.791E-2 * METER
QUARTER_DIAMETER = 2.426E-2 * METER
PENNY_MASS = 2.5 * GRAM
NICKEL_MASS = 5.0 * GRAM
DIME_MASS = 0.005 * POUND
QUARTER_MASS = 0.0125 * POUND
MOON_MONTH = 29.530587981 * DAY
MILKYWAY_AGE = 8.3E+9 * JYEAR
ASTRONOMICALUNIT = AU
LIGHTYEAR = LIGHT * JYEAR
PARSEC = 1296000.0 * ASTRONOMICALUNIT / TAU
PROXIMACENTAURI = 39.9E+15 * METER
MILKYWAY_RADIUS = 6.0E+4 * LIGHTYEAR
GALACTICCENTER = 2.64E+4 * LIGHTYEAR
MILKYWAY_MASS = 1.4E+42 * KILOGRAM
SOLARCONSTANT = 1361.0 * WATT / (METER * (METER))
UNIVERSE_AGE = 13.799E+9 * JYEAR
UNIVERSE_RADIUS = 14.26E+9 * PARSEC
UNIVERSE_MASS = 1.46E+53 * KILOGRAM
EINSTEIN = 4.0 * TAU * GRAVITATION / (LIGHT * (LIGHT) * (LIGHT) * (LIGHT))
EINSTEIN_ERR = GRAVITATION_ERR
HUBBLE = 67.66E-3 * METER / (SECOND * PARSEC)
HUBBLE_ERR = 6.0E-3
HUBBLERADIUS = LIGHT / HUBBLE
BHMASSTEMP = ((LIGHT * (LIGHT) * (LIGHT)) * HBAR / (4.0 * TAU *\
GRAVITATION * BOLTZMANN))
BHMASS_RADIUS = 0.5 * (LIGHT * (LIGHT)) / GRAVITATION
BHMASS3_LIFETIME = (PLANCK * (LIGHT * (LIGHT) * (LIGHT) * (LIGHT))) /\
(2560.0 * (TAU * (TAU)) * (GRAVITATION * (GRAVITATION)))
BHRADIUS2DENSITY = 1.5 * BHMASS_RADIUS / TAU
BHMASS2_ENTROPY = (PLANCK * LIGHT) / (2.0 * TAU * TAU * GRAVITATION *\
BOLTZMANN)
BHENTROPY_AREA = (TAU * (LIGHT * (LIGHT) * (LIGHT)) * BOLTZMANN) / (4.0 *\
PLANCK * GRAVITATION)
BHMASS2POWER = (LIGHT * (LIGHT) * (LIGHT) * (LIGHT) * (LIGHT) * (LIGHT))\
* PLANCK / (7680.0 * (TAU * (TAU)) * (GRAVITATION * (GRAVITATION)))
BHMASS2_AREA = BHMASS2_ENTROPY * BHENTROPY_AREA
BHMASS2_DENSITY = (BHMASS_RADIUS * (BHMASS_RADIUS)) * BHRADIUS2DENSITY
BEKENSTEININFORMATION = ((TAU * (TAU)) * NAT) / (PLANCK * LIGHT)
BEKENSTEINENTROPY = ((TAU * (TAU)) * BOLTZMANN) / (PLANCK * LIGHT)
ELEVATIONMAX = 8848.0 * METER
ELEVATIONMIN = -10994.0 * METER
KPGBOUNDARY = 65.5E+6 * JYEAR
TRJBOUNDARY = 199.6E+6 * JYEAR
MILKYWAY_DAY = 250.0E+6 * JYEAR
PTRBOUNDARY = 251.4E+6 * JYEAR
NPBOUNDARY = 542.0E+6 * JYEAR
LIFE_AGE = 3.85E+9 * JYEAR
GIANTIMPACT = 4.533E+9 * JYEAR
EARTH_AGE = 4.56717E+9 * JYEAR
PPQ = 1.0E-15
PPT = 1.0E-12
PPB = 1.0E-9
PPM = 1.0E-6
PERMILLE = 1.0E-3
PERCENT = 1.0E-2
SOLID_ANGLE = STERADIAN
SPEED = LENGTH / TIME
ACCELERATION = SPEED / TIME
FORCE = MASS * ACCELERATION
ENERGY = FORCE * LENGTH
ACTION = ENERGY * TIME
POWER = ENERGY / TIME
AREA = (LENGTH * (LENGTH))
VOLUME = (LENGTH * (LENGTH) * (LENGTH))
DENSITY = MASS / VOLUME
SPECIFICHEAT = ENERGY / (MASS * TEMPERATURE)
PRESSURE = FORCE / AREA
VISCOSITY = FORCE * TIME / AREA
FREQUENCY = 1 / TIME
VOLTAGE = POWER / CURRENT
RESISTANCE = VOLTAGE / CURRENT
INDUCTANCE = RESISTANCE * TIME
CAPACITANCE = CHARGE / VOLTAGE
CONDUCTANCE = 1.0 / RESISTANCE
MAGNETICFLUX = VOLTAGE * TIME
MAGNETICINDUCTION = MAGNETICFLUX / AREA
# IIIIIIIIIIMPORT_MASTER-Function ############################# lf_mod_py #
def lf_mod_py(xx,yy):
xx = int(xx)
yy = int(yy)
retvalu = xx % yy
if retvalu < 0:
retvalu += abs(yy)
return(retvalu)
# IIIIIIIIIIMPORT_MASTER-Function ################################# atan2 #
def atan2(xx, yy): return(math.atan2(xx, yy))
# IIIIIIIIIIMPORT_MASTER-Function ################################## fmod #
def fmod(xx, yy): return(math.fmod(xx, yy))
# IIIIIIIIIIMPORT_MASTER-Function ################################# timee #
def timee(): return(time.time())
# IIIIIIIIIIMPORT_MASTER-Function ################################### abs #
def abs(xx): return(math.fabs(xx))
# IIIIIIIIIIMPORT_MASTER-Function ################################# floor #
def floor(xx): return(math.floor(xx))
# IIIIIIIIIIMPORT_MASTER-Function ################################## ceil #
def ceil(xx): return(math.ceil(xx))
# IIIIIIIIIIMPORT_MASTER-Function ################################ floorl #
def floorl(xx): return(int(math.floor(xx)))
# IIIIIIIIIIMPORT_MASTER-Function ################################# ceill #
def ceill(xx): return(int(math.ceil(xx)))
# IIIIIIIIIIMPORT_MASTER-Function ################################## sqrt #
def sqrt(xx): return(math.sqrt(xx))
# IIIIIIIIIIMPORT_MASTER-Function ################################### exp #
def exp(xx): return(math.exp(xx))
# IIIIIIIIIIMPORT_MASTER-Function ################################### log #
def log(xx): return(math.log(xx))
# IIIIIIIIIIMPORT_MASTER-Function ################################### pow #
def pow(xx, yy): return(math.exp(yy * math.log(xx)))
# IIIIIIIIIIMPORT_MASTER-Function ################################### sin #
def sin(xx): return(math.sin(xx))
# IIIIIIIIIIMPORT_MASTER-Function ################################### cos #
def cos(xx): return(math.cos(xx))
# IIIIIIIIIIMPORT_MASTER-Function ################################### tan #
def tan(xx): return(math.sin(xx) / math.cos(xx))
def id(xx):
return (xx)
def reci(xx):
return (1.0 / xx)
def neg(xx):
return (- xx)
def square(xx):
return (xx * xx)
def sq(xx):
return (xx * xx)
def sqinv(xx):
return (math.sqrt(xx))
def cube(xx):
return (xx * xx * xx)
def cu(xx):
return (xx * xx * xx)
def sign(xx):
if (xx < 0.0):
retvalu = -1.0
elif (0.0 < xx):
retvalu = 1.0
else:
retvalu = 0.0
return (retvalu)
def stair(xx):
if (xx < 0.0):
retvalu = 0.0
else:
retvalu = 1.0
return (retvalu)
def heaviside(xx):
if (xx < 0.0):
retvalu = 0.0
elif (0.0 < xx):
retvalu = 1.0
else:
retvalu = 0.5
return (retvalu)
def divi(numer, denom, def_val):
if (denom < 0.0 or 0.0 < denom):
retvalu = numer / denom
else:
retvalu = def_val
return (retvalu)
def clip(xx):
if (xx < 0.0):
retvalu = 0.0
else:
retvalu = xx
return (retvalu)
def clip2(xx, xlow, xhigh):
if (xx <= xlow):
retvalu = xlow
elif (xx <= xhigh):
retvalu = xx
else:
retvalu = xhigh
return (retvalu)
def clip2x(xx, xa, xb):
if (xb < xa):
if (xx <= xb or xa <= xx):
retvalu = xx
elif (2.0 * xx < xa + xb):
retvalu = xb
else:
retvalu = xa
else:
if (xx <= xa):
retvalu = xa
elif (xx <= xb):
retvalu = xx
else:
retvalu = xb
return (retvalu)
def sba(xx):
if (- 1.0 < xx and xx < 1.0):
retvalu = xx
else:
retvalu = 1.0 / xx
return (retvalu)
def ratio(aa, bb):
if (math.fabs(aa) < math.fabs(bb)):
rati = aa / bb
else:
rati = bb / aa
return (rati)
def horner(xx, deg, coefh_arr_pc):
sum_curr = coefh_arr_pc[deg]
for jj in range(deg - 1, -1, -1):
sum_curr *= xx
sum_curr += coefh_arr_pc[jj]
return (sum_curr)
def chebeval(xx, deg, cheb_arr_pc):
xx *= 2.0
ba = cheb_arr_pc[deg]
bb = 0.0
bc = 0.0
for ii in range(deg - 1, -1, -1):
bc = bb
bb = ba
ba = xx * bb - bc + cheb_arr_pc[ii]
return ((ba - bc) / 2.0)
def ln(xx):
return (math.log(xx))
def lg(xx):
return (math.log(xx) / TWOLN)
def log10(xx):
return (math.log(xx) / math.log(10.0))
def logx(xx, bb):
return (math.log(xx) / math.log(bb))
def l10(xx):
return (math.log(xx) / math.log(10.0))
def log2(xx):
return (math.log(xx) / TWOLN)
def fmody(xx, yymodulus):
if (yymodulus < 0.0 or 0.0 < yymodulus):
retvalu = xx - floor(xx / yymodulus) * yymodulus
else:
retvalu = 0.0
return (retvalu)
def fmodu(xx, yymodulus):
if (yymodulus < 0.0 or 0.0 < yymodulus):
retvalu = fmod(xx, yymodulus)
if (retvalu < 0.0):
retvalu += math.fabs(yymodulus)
else:
retvalu = 0.0
return (retvalu)
def remquou(xx, yymodulus, ret_int_arr_p):
if (yymodulus < 0.0 or 0.0 < yymodulus):
qu = xx / yymodulus
fl = floor(qu)
retvalu = qu - fl
else:
fl = 0.0
retvalu = xx
ret_int_arr_p[0] = fl
return (retvalu)
def fmods(xx, yymodulus):
if (yymodulus < 0.0 or 0.0 < yymodulus):
retvalu = fmod(xx, yymodulus)
ayy = math.fabs(yymodulus)
lim = ayy / 2.0
if (retvalu < - lim):
retvalu += ayy
elif (lim <= retvalu):
retvalu -= ayy
else:
retvalu = 0.0
return (retvalu)
def pow2(expo):
return (math.pow(2.0, expo))
def pow10(expo):
return (math.pow(10.0, expo))
def sigmoid(xx):
return (1.0 / (1.0 + math.exp(-xx)))
def sigmoidinv(xx):
return (- math.log(((1.0 / xx - 0.5) - 0.5)))
def sigmoid3(aa, bb, xx):
if (aa <= 0.0 or 1.0 <= aa or bb <= 0.0 or 1.0 <= bb):
retvalu = 0.0
else:
taa = math.log((1.0 - aa) / aa)
alfa = math.log((1.0 - bb) / bb) - taa
xzero = -taa / alfa
retvalu = 1.0 / (1.0 + math.exp(alfa * (xx - xzero)))
return (retvalu)
def taninv3(aa, bb, xx):
if (aa <= 0.0 or 1.0 <= aa or bb <= 0.0 or 1.0 <= bb):
retvalu = 0.0
else:
taa = math.tan((aa - 0.5) * PI)
alfa = math.tan((bb - 0.5) * PI) - taa
retvalu = taninv(alfa * xx + taa) / PI + 0.5
return (retvalu)
def sigmoid3d(aa, bb, xx):
if (aa <= 0.0 or 1.0 <= aa or bb <= 0.0 or 1.0 <= bb):
retvalu = 0.0
else:
taa = math.log((1.0 - aa) / aa)
alfa = math.log((1.0 - bb) / bb) - taa
xzero = -taa / alfa
expa = math.exp(alfa * (xx - xzero))
retvalu = -alfa * expa / square(1.0 + expa)
return (retvalu)
def sqrtx(xx):
if (xx < 0.0):
retvalu = -math.sqrt(-xx)
else:
retvalu = math.sqrt(xx)
return (retvalu)
def smooth(xx):
if (xx <= -1.0):
retvalu = 0.0
elif (1.0 <= xx):
retvalu = 1.0
else:
retvalu = sigmoid(4.0 * xx / (1.0 - xx * xx))
return (retvalu)
def hypot(xx, yy):
axx = math.fabs(xx)
ayy = math.fabs(yy)
if (axx < ayy):
retvalu = ayy
ayy = axx
axx = retvalu
if (0.0 < axx):
if (ayy < DBLEPS * axx):
retvalu = axx
else:
ayy /= axx
retvalu = axx * math.sqrt(1.0 + ayy * ayy)
else:
retvalu = 0.0
return (retvalu)
def hypot1(xx):
return (hypot(1.0, xx))
def hypot1inv(xx):
return (math.sqrt(xx * xx - 1.0))
def hypot3(xx, yy, zz):
return (math.sqrt(xx * xx + yy * yy + zz * zz))
def topyh(xx, yy):
xsq = xx * xx
ysq = yy * yy
if (ysq <= 0.0):
retvalu = xx
elif (xsq <= 0.0):
retvalu = yy
elif (xsq < ysq):
xsq /= ysq
retvalu = -sign(xx) * math.sqrt(1.0 - xsq) * math.fabs(yy)
else:
ysq /= xsq
retvalu = math.sqrt(1.0 - ysq) * xx
return (retvalu)
def topyh1(xx):
if (xx < - 1.0 or 1.0 < xx):
retvalu = -math.sqrt(xx * xx - 1.0)
else:
retvalu = math.sqrt(1.0 - xx * xx)
return (retvalu)
def cnv_dbl2si16(xx):
if (xx <= SI16MIN):
retvalu = SI16MIN
elif (xx <= SI16MAX):
retvalu = floorl(xx + 0.5)
else:
retvalu = SI16MAX
return int(retvalu)
def k2tempc(temp_k):
return ((temp_k - K_AT_0TEMPC) * KELVIN / DEGC)
def tempc2k(temp_c):
return (temp_c * DEGC / KELVIN + K_AT_0TEMPC)
def k2tempf(temp_k):
return ((temp_k - K_AT_0TEMPF) * KELVIN / DEGF)
def tempf2k(temp_f):
return (temp_f * DEGF / KELVIN + K_AT_0TEMPF)
def k2tempr(temp_k):
return ((temp_k - K_AT_0TEMPR) * KELVIN / DEGR)
def tempr2k(temp_r):
return (temp_r * DEGR / KELVIN + K_AT_0TEMPR)
def tempf2tempc(temp_f):
return ((temp_f - TEMPF_AT_0TEMPC) * DEGF)
def tempc2tempf(temp_c):
return (temp_c / DEGF + TEMPF_AT_0TEMPC)
def iszero(xx):
return (0.0 <= xx and xx <= 0.0)
def iseven(xx):
return (fmodu(xx, 2.0) < 1.0)
def isodd(xx):
return (1.0 <= fmodu(xx, 2.0))
def ismult(xx, mult):
return (fmodu(xx, mult) < 1.0)
def ismultl(xx, mult):
if (xx % mult == 0):
retvalu_bol = True
else:
retvalu_bol = False
return (retvalu_bol)
def isgt(xx, yy):
return (yy < xx)
def islt(xx, yy):
return (xx < yy)
def isge(xx, yy):
return (yy <= xx)
def isle(xx, yy):
return (xx <= yy)
def ispos(xx):
return (0.0 < xx)
def isneg(xx):
return (xx < 0.0)
def iseq(xx, yy):
retvalu_bol = False
if (iszero(xx)):
if (math.fabs(yy) <= DBLEPS):
retvalu_bol = True
else:
epsx = 2.0 * xx * DBLEPS
diffxy = xx - yy
if (epsx < 0.0):
epsx = -epsx
if (- epsx <= diffxy and diffxy <= epsx):
retvalu_bol = True
return (retvalu_bol)
def isneq(xx, yy):
return (xx < yy or yy < xx)
def isint(xx):
return (iseq(xx, floor(xx)))
def isnegint(xx):
return (xx < 0.0 and iseq(xx, floor(xx)))
def isposint(xx):
return (0.0 < xx and iseq(xx, floor(xx)))
def ifzero(cond, tru_val, fal_val):
if (cond < 0.0 or 0.0 < cond):
retvalu = fal_val
else:
retvalu = tru_val
return (retvalu)
def isalmostequal(xx, yy, epsratio):
return (math.fabs(xx - yy) <= math.fabs(epsratio * xx))
def iswithin(xx, yy, delta):
return (xx - delta <= yy and yy <= xx + delta)
def isbetweenx(xx, min_xx, max_xx):
return (min_xx < xx and xx < max_xx)
def isbetween(xx, min_xx, max_xx):
return (min_xx <= xx and xx <= max_xx)
def isleapyear(gregyear):
retvalu_bol = False
if ((gregyear % 4) == 0):
rema = (gregyear % 400)
if (rema != 100 and rema != 200 and rema != 300):
retvalu_bol = True
return (retvalu_bol)
def isss(xx, yy):
if (0.0 < xx):
if (0.0 < yy):
retvalu_bol = True
else:
retvalu_bol = False
elif (xx < 0.0):
if (yy < 0.0):
retvalu_bol = True
else:
retvalu_bol = False
else:
if (0.0 < yy or yy < 0.0):
retvalu_bol = False
else:
retvalu_bol = True
return (retvalu_bol)
def issignsame(xx, yy):
return (isss(xx, yy))
def isfloorsame(xx, yy, multy):
return (iseq(floor(xx * multy), floor(yy * multy)))
LC_MAGIC_INT = 2070108020
LC_MAGIC_INT_NOT = 301040105
def magicset():
return int(LC_MAGIC_INT)
def magicnot():
return int(LC_MAGIC_INT_NOT)
def ismagic(xx):
return (iseq(xx, magicset()))
def rtoz(xx):
if (xx < 0.0):
retvalu = math.ceil(xx)
else:
retvalu = floor(xx)
return (retvalu)
def rtoi(xx):
if (0.0 <= xx):
retvalu = math.ceil(xx)
else:
retvalu = floor(xx)
return (retvalu)
def bankers(xx):
retvalu = floor(xx + 0.5)
if (isint(xx + 0.5) and isodd(retvalu)):
retvalu -= 1.0
return (retvalu)
def round(xx):
retvalu = floor(xx + 0.5)
return (retvalu)
def iround(xx):
retvalu = floor(xx + 0.5)
return int(retvalu)
def round2(xx, yy):
if (iszero(yy)):
retvalu = xx
else:
retvalu = round(xx / yy) * yy
return (retvalu)
def roundy(xx, yy, shf):
if (yy < 0.0 or 0.0 < yy):
retvalu = (round((xx - shf) / yy) * yy + shf)
else:
retvalu = xx
return (retvalu)
def rtomsd(fs, msds):
if (iszero(fs)):
retvalu = 0.0
else:
if (fs < 0.0):
signs = -1.0
fs = -fs
else:
signs = 1.0
logi = floor(log10(fs) - msds + 1.0)
retvalu = signs * round2(fs, math.pow(10.0, logi))
return (retvalu)
def rto125(fs):
if (iszero(fs)):
retvalu = 0.0
else:
if (fs < 0.0):
signs = -1.0
fs = -fs
else:
signs = 1.0
pow_ten = math.pow(10.0, floor(log10(fs)))
tmpf = fs / pow_ten
if (tmpf < math.sqrt(2.0)):
valu = 1.0
elif (tmpf < math.sqrt(10.0)):
valu = 2.0
elif (tmpf < math.sqrt(50.0)):
valu = 5.0
else:
valu = 10.0
retvalu = signs * pow_ten * valu
return (retvalu)
def floor2(xx, yy):
if (iszero(yy)):
retvalu = 0.0
else:
retvalu = floor(xx / math.fabs(yy)) * math.fabs(yy)
return (retvalu)
def ceil2(xx, yy):
if (iszero(yy)):
retvalu = 0.0
else:
retvalu = math.ceil(xx / math.fabs(yy)) * math.fabs(yy)
return (retvalu)
def fmod2(xx, minn, maxx):
if (iseq(maxx, minn)):
retvalu = 0.0
else:
retvalu = fmodu(xx - minn, maxx - minn) + minn
return (retvalu)
def frac(xx):
return (xx - floor(xx))
def trunc(xx):
if (0.0 <= xx):
retvalu = xx - floor(xx)
else:
retvalu = xx - math.ceil(xx)
return (retvalu)
def fmul(xx, pp):
lpp = math.log(pp)
return (math.exp(lpp * frac(math.log(xx) / lpp)))
def dist(xx, xmoduli):
axx = math.fabs(xx)
axmoduli = math.fabs(xmoduli)
retvalu = fmod(axx, axmoduli)
if (axmoduli < 2.0 * retvalu):
retvalu = axmoduli - retvalu
return (retvalu)
def ddist(xx, xmoduli):
if (iszero(xmoduli)):
retvalu = 0.0
else:
axmoduli = math.fabs(xmoduli)
rema = xx - floor(xx / axmoduli) * axmoduli
if (axmoduli < 2.0 * rema):
rema -= axmoduli
retvalu = rema
return (retvalu)
def sinc(xx_rad):
if (xx_rad < 0.0 or 0.0 < xx_rad):
retvalu = math.sin(xx_rad) / xx_rad
else:
retvalu = 1.0
return (retvalu)
def sincinv(yy):
min_xx = 4.4934094579090641753079882808139693729311345
min_yy = sinc(min_xx)
if (yy <= min_yy):
nrvx_xx = min_xx
elif (yy < 1.0):
aa = yy - min_yy
bb = 1.0 - yy
start_xx = (aa * math.sqrt(5.0 * bb) + bb * (min_xx - math.sqrt(6.0\
* aa))) / (1.0 - min_yy)
nrvx_xx = start_xx
for nrvx_ii in range(0, 21, 1):
nrvx_xp = nrvx_xx
nrvx_dy = math.cos(nrvx_xx) - yy
if (iszero(nrvx_dy)):
break
nrvx_yy = math.sin(nrvx_xx) - yy * nrvx_xx
nrvx_xx -= nrvx_yy / nrvx_dy
if (iseq(nrvx_xp, nrvx_xx)):
break
else:
nrvx_xx = 0.0
return (nrvx_xx)
def sincc(xx_rad):
if (iszero(xx_rad)):
retvalu = 1.0
else:
xr_rad = fmod(xx_rad, TAU)
if (TAU / 2.0 < xr_rad):
xr_rad = TAU - xr_rad
trigsign = -1.0
else:
trigsign = 1.0
if (TAU / 4.0 < xr_rad):
xr_rad = TAU / 2.0 - xr_rad
nxr_sqr = -xr_rad * xr_rad
sum_curr = xr_rad
term = xr_rad
ii = 2
while True:
term *= nxr_sqr / (ii * (ii - 1.0))
sum_prev = sum_curr
sum_curr += term
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
ii += 2
retvalu = trigsign * sum_curr * xr_rad / xx_rad
return (retvalu)
def versin(circ_rad):
xr_rad = fmod(circ_rad, TAU)
if (TAU / 2.0 < xr_rad):
xr_rad = TAU - xr_rad
if (TAU / 4.0 < xr_rad):
xr_rad = TAU / 2.0 - xr_rad
trigsign = -1.0
else:
trigsign = 1.0
xr_sqr = -xr_rad * xr_rad
sum_curr = 1.0 / 2.0
term = 1.0 / 2.0
ii = 4
while True:
term *= xr_sqr / (ii * (ii - 1.0))
sum_prev = sum_curr
sum_curr += term
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
ii += 2
sum_curr *= - xr_sqr
if (trigsign < 0.0):
sum_curr = 2.0 - sum_curr
return (sum_curr)
def haversin(circ_rad):
return (versin(circ_rad) / 2.0)
def tur2deg(circ_tur):
return (circ_tur * TURN / ARCDEG)
def deg2tur(circ_deg):
return (circ_deg * ARCDEG / TURN)
def tur2rad(circ_tur):
return (circ_tur * TURN / RADIAN)
def rad2tur(circ_rad):
return (circ_rad * RADIAN / TURN)
def tur2sec(circ_tur):
return (circ_tur * TURN / ARCSEC)
def sec2tur(circ_sec):
return (circ_sec * ARCSEC / TURN)
def rad2deg(circ_rad):
return (circ_rad * RADIAN / ARCDEG)
def deg2rad(circ_deg):
return (circ_deg * ARCDEG / RADIAN)
def rad2sec(circ_rad):
return (circ_rad * RADIAN / ARCSEC)
def sec2rad(circ_sec):
return (circ_sec * ARCSEC / RADIAN)
def deg2sec(circ_deg):
return (circ_deg * ARCDEG / ARCSEC)
def sec2deg(circ_sec):
return (circ_sec * ARCSEC / ARCDEG)
def rad2dms(xx_rads):
dg = rad2deg(xx_rads)
dd_deg = floor(dg)
dg = (dg - dd_deg) * ARCDEG / ARCMIN
mm_min = floor(dg)
dg = (dg - mm_min) * ARCMIN / ARCSEC
return (dd_deg + (mm_min + dg / 100.0) / 100.0)
def rad2dms2(circ_rads):
dd_deg_arr = [0 for ii in range(2)]
mm_min_arr = [0 for ii in range(2)]
dg = rad2deg(circ_rads)
dg = modf(dg, dd_deg_arr) * ARCDEG / ARCMIN
dg = modf(dg, mm_min_arr) * ARCMIN / ARCSEC
return (dd_deg_arr[0] + (mm_min_arr[0] + dg / 100.0) / 100.0)
def dms2rad(circ_dms):
dd_deg = floor(circ_dms)
dg = (circ_dms - dd_deg) * 100.0
mm_min = floor(dg)
dg = (dg - mm_min) * 100.0
return ((dg * ARCSEC + mm_min * ARCMIN + dd_deg * ARCDEG) / RADIAN)
def deg2dms(circ_deg):
return (rad2dms(deg2rad(circ_deg)))
def dms2deg(circ_dms):
return (rad2deg(dms2rad(circ_dms)))
def cot(circ_rad):
return (math.cos(circ_rad) / math.sin(circ_rad))
def sec(circ_rad):
return (1.0 / math.cos(circ_rad))
def csc(circ_rad):
return (1.0 / math.sin(circ_rad))
def sininv(xx):
return (math.atan2(xx, topyh1(xx)))
def cosinv(xx):
return (math.atan2(topyh1(xx), xx))
def taninv(xx):
return (math.atan2(xx, 1.0))
def cotinv(xx):
return (math.atan2(1.0, xx))
def secinv(xx):
return (math.atan2(math.sqrt(xx * xx - 1.0), sign(xx)))
def cscinv(xx):
return (math.atan2(sign(xx), math.sqrt(xx * xx - 1.0)))
def sinh(hyp_rad):
return ((math.exp(hyp_rad) - math.exp(-hyp_rad)) / 2.0)
def cosh(hyp_rad):
return ((math.exp(hyp_rad) + math.exp(-hyp_rad)) / 2.0)
def tanh(hyp_rad):
return (sinh(hyp_rad) / cosh(hyp_rad))
def coth(hyp_rad):
return (cosh(hyp_rad) / sinh(hyp_rad))
def sech(hyp_rad):
return (1.0 / cosh(hyp_rad))
def csch(hyp_rad):
return (1.0 / sinh(hyp_rad))
def gd(hyp_rad):
return (2.0 * math.atan2(math.exp(hyp_rad), 1.0) - PI / 2.0)
def gdinv(xx):
xxn = fmods(xx, PI)
return (math.log(math.fabs((1.0 + math.sin(xxn)) / math.cos(xxn))))
def sinhinv(xx):
return (math.log(xx + math.sqrt(xx * xx + 1.0)))
def coshinv(xx):
return (math.log(xx + math.sqrt(xx * xx - 1.0)))
def tanhinv(xx):
return (math.log((1.0 + xx) / (1.0 - xx)) / 2.0)
def cothinv(xx):
return (math.log((xx + 1.0) / (xx - 1.0)) / 2.0)
def sechinv(xx):
return (math.log((1.0 + topyh1(xx)) / xx))
def cschinv(xx):
return (math.log((1.0 + math.sqrt(1.0 + xx * xx)) / xx))
def atan2h(xx, yy):
if (math.fabs(yy) <= math.fabs(xx)):
retvalu = 0.0
else:
retvalu = math.log((yy + xx) / (yy - xx)) / 2.0
return (retvalu)
def atan2u(xx, yy):
return (fmodu(math.atan2(xx, yy), tur2rad(1.0)))
def sind(circ_deg):
return (math.sin(deg2rad(circ_deg)))
def sindinv(xx):
return (rad2deg(sininv(xx)))
def cosd(circ_deg):
return (math.cos(deg2rad(circ_deg)))
def cosdinv(xx):
return (rad2deg(cosinv(xx)))
def tand(circ_deg):
return (math.tan(deg2rad(circ_deg)))
def tandinv(xx):
return (rad2deg(taninv(xx)))
def cotd(circ_deg):
return (cot(deg2rad(circ_deg)))
def cotdinv(xx):
return (rad2deg(cotinv(xx)))
def secd(circ_deg):
return (sec(deg2rad(circ_deg)))
def secdinv(xx):
return (rad2deg(secinv(xx)))
def cscd(circ_deg):
return (csc(deg2rad(circ_deg)))
def cscdinv(xx):
return (rad2deg(cscinv(xx)))
def atan2d(xx, yy):
return (rad2deg(math.atan2(xx, yy)))
def sint(circ_tur):
return (math.sin(tur2rad(circ_tur)))
def sintinv(xx):
return (rad2tur(sininv(xx)))
def cost(circ_tur):
return (math.cos(tur2rad(circ_tur)))
def costinv(xx):
return (rad2tur(cosinv(xx)))
def tant(circ_tur):
return (math.tan(tur2rad(circ_tur)))
def tantinv(xx):
return (rad2tur(taninv(xx)))
def cott(circ_tur):
return (cot(tur2rad(circ_tur)))
def cottinv(xx):
return (rad2tur(cotinv(xx)))
def sect(circ_tur):
return (sec(tur2rad(circ_tur)))
def sectinv(xx):
return (rad2tur(secinv(xx)))
def csct(circ_tur):
return (csc(tur2rad(circ_tur)))
def csctinv(xx):
return (rad2tur(cscinv(xx)))
def atan2t(xx, yy):
return (rad2tur(math.atan2(xx, yy)))
def sqrtxp1m1(xx):
if (math.fabs(xx) < 0.01):
retvalu = ((((((((-429.0 / 32768.0) * xx + 33.0 / 2048.0) * xx -\
21.0 / 1024.0) * xx + 7.0 / 256.0) * xx - 5.0 / 128.0) *\
xx + 1.0 / 16.0) * xx - 1.0 / 8.0) * xx + 1.0 / 2.0) * xx
else:
retvalu = math.sqrt(1.0 + xx) - 1.0
return (retvalu)
def ln1p(xx):
if (0.1 < math.fabs(xx)):
retvalu = math.log(1.0 + xx)
elif (iszero(xx)):
retvalu = 0.0
else:
start = math.ceil(math.fabs(math.log(DBLEPS) /\
math.log(math.fabs(xx))))
if (start < 2):
start = 2
sum_curr = 0.0
for jj in range(start, 0, -1):
sum_curr = 1.0 / jj - sum_curr * xx
retvalu = sum_curr * xx
return (retvalu)
def expm1(xx):
if (0.1 < math.fabs(xx)):
retvalu = math.exp(xx) - 1.0
elif (iszero(xx)):
retvalu = 0.0
else:
start = math.ceil(math.fabs(math.log(DBLEPS) /\
math.log(math.fabs(xx))))
if (start < 2):
start = 2
sum_curr = 0.0
for jj in range(start, 0, -1):
sum_curr = xx * (1.0 + sum_curr) / jj
retvalu = sum_curr
return (retvalu)
def cosm1(xx):
if (0.1 < math.fabs(xx)):
retvalu = math.cos(xx) - 1.0
elif (iszero(xx)):
retvalu = 0.0
else:
start = math.ceil(math.fabs(math.log(DBLEPS) /\
math.log(math.fabs(xx))))
if (start < 6):
start = 6
elif (isodd(start)):
start += 1
xr_sqr = -xx * xx
sum_curr = 1.0 / (start * (start + 1.0))
for jj in range(start, 0, -2):
sum_curr += 1.0
sum_curr *= xr_sqr / (jj * (jj - 1.0))
retvalu = sum_curr
return (retvalu)
def lns(xx):
aa = math.fabs(xx)
if (aa < 1.0 / DBLMAX):
retvalu = -DBLMAXLN - 1.0
else:
retvalu = math.log(aa)
return (retvalu)
def trip(xx):
fx = 4.0 * frac(xx)
if (fx < 2.0):
retvalu = 1.0 - fx
else:
retvalu = fx - 3.0
return (retvalu)
def lf_cbrtx_gt_zero(xx):
zz = 64.0 * xx / 27.0
yy = 1.0
while (zz <= 1.0):
zz *= 8.0
yy /= 2.0
while (8.0 < zz):
zz /= 8.0
yy *= 2.0
return (yy)
def cbrt(yy):
ayy = math.fabs(yy)
if (0.0 < ayy):
init_xx = lf_cbrtx_gt_zero(ayy)
if (yy < 0.0):
init_xx = -init_xx
nrvx_xx = init_xx
for nrvx_ii in range(0, 21, 1):
nrvx_xp = nrvx_xx
nrvx_dy = 3.0 * nrvx_xx * nrvx_xx
if (iszero(nrvx_dy)):
break
nrvx_yy = nrvx_xx * nrvx_xx * nrvx_xx - yy
nrvx_xx -= nrvx_yy / nrvx_dy
if (iseq(nrvx_xp, nrvx_xx)):
break
else:
nrvx_xx = 0.0
return (nrvx_xx)
def cuberoot(xx):
return (cbrt(xx))
def squareroot(xx):
return (math.sqrt(xx))
def print_array(arr_size, data_arr_pc):
for ii in range(0, arr_size + 0, 1):
print(str(data_arr_pc[ii]), end='')
print(" ", end='')
return int(arr_size)
def lf_continued_fraction(orig, show_diff):
steps = 0
xx = orig
den_b = 0
num_b = 1
den_a = 1
num_a = 0
epsilon = DBLEPS / 2.0
while True:
whole = floorl(xx)
den_c = den_b * whole + den_a
num_c = num_b * whole + num_a
den_a = den_b
num_a = num_b
den_b = den_c
num_b = num_c
steps += 1
appr = (1.0 * num_b / den_b)
diff = orig - appr
print("", end='')
print(str(whole), end='')
if (0 <= show_diff):
print("\t", end='')
print(str(num_b), end='')
print(" / ", end='')
print(str(den_b), end='')
print("\t", end='')
print(str(appr), end='')
if (0 < show_diff):
print("\t", end='')
print(str(diff), end='')
print("\n", end='')
else:
print(" ", end='')
if (iseq(xx, whole)):
break
xx = 1.0 / (xx - whole)
epsilon *= 2.0
if (math.fabs(diff) < epsilon):
break# loop AWAIT
return int(steps)
def contfra_print(orig):
return int((lf_continued_fraction(orig, -1)))
def contfrac_print(orig):
return int((lf_continued_fraction(orig, 0)))
def contfracd_print(orig):
return int((lf_continued_fraction(orig, 1)))
def num2char_print(num):
if (num < 32):
if (num < 16):
if (num < 8):
if (num < 4):
if (num < 2):
if (num < 1):
print("0", end='')
else:
print("1", end='')
elif (num < 3):
print("2", end='')
else:
print("3", end='')
elif (num < 6):
if (num < 5):
print("4", end='')
else:
print("5", end='')
elif (num < 7):
print("6", end='')
else:
print("7", end='')
elif (num < 12):
if (num < 10):
if (num < 9):
print("8", end='')
else:
print("9", end='')
elif (num < 11):
print("a", end='')
else:
print("b", end='')
elif (num < 14):
if (num < 13):
print("c", end='')
else:
print("d", end='')
elif (num < 15):
print("e", end='')
else:
print("f", end='')
elif (num < 24):
if (num < 20):
if (num < 18):
if (num < 17):
print("g", end='')
else:
print("h", end='')
elif (num < 19):
print("i", end='')
else:
print("j", end='')
elif (num < 22):
if (num < 21):
print("k", end='')
else:
print("l", end='')
elif (num < 23):
print("m", end='')
else:
print("n", end='')
elif (num < 28):
if (num < 26):
if (num < 25):
print("o", end='')
else:
print("p", end='')
elif (num < 27):
print("q", end='')
else:
print("r", end='')
elif (num < 30):
if (num < 29):
print("s", end='')
else:
print("t", end='')
elif (num < 31):
print("u", end='')
else:
print("v", end='')
elif (num < 48):
if (num < 40):
if (num < 36):
if (num < 34):
if (num < 33):
print("w", end='')
else:
print("x", end='')
elif (num < 35):
print("y", end='')
else:
print("z", end='')
elif (num < 38):
if (num < 37):
print("A", end='')
else:
print("B", end='')
elif (num < 39):
print("C", end='')
else:
print("D", end='')
elif (num < 44):
if (num < 42):
if (num < 41):
print("E", end='')
else:
print("F", end='')
elif (num < 43):
print("G", end='')
else:
print("H", end='')
elif (num < 46):
if (num < 45):
print("I", end='')
else:
print("J", end='')
elif (num < 47):
print("K", end='')
else:
print("L", end='')
elif (num < 56):
if (num < 52):
if (num < 50):
if (num < 49):
print("M", end='')
else:
print("N", end='')
elif (num < 51):
print("O", end='')
else:
print("P", end='')
elif (num < 54):
if (num < 53):
print("Q", end='')
else:
print("R", end='')
elif (num < 55):
print("S", end='')
else:
print("T", end='')
elif (num < 60):
if (num < 58):
if (num < 57):
print("U", end='')
else:
print("V", end='')
elif (num < 59):
print("W", end='')
else:
print("X", end='')
elif (num < 62):
if (num < 61):
print("Y", end='')
else:
print("Z", end='')
elif (num < 63):
print("_", end='')
elif (num < 64):
print("?", end='')
else:
print("(", end='')
print(str(num), end='')
print(")", end='')
return int(num)
def base_out_print(num, baset):
digits_arr = [0 for ii in range(65)]
if (num < 0):
print("-", end='')
num = -num
dig_count = 0
while True:
digits_arr[dig_count] = num % baset
dig_count += 1
num = floorl(num / baset)
if (num == 0):
break# loop AWAIT
for ii in range(dig_count - 1, -1, -1):
num2char_print(digits_arr[ii])
return int(dig_count)
def base_out_fix_print(num, baset, min_sz):
digits_arr = [0 for ii in range(65)]
if (num < 0):
num = -num
dig_count = 0
while True:
digits_arr[dig_count] = num % baset
dig_count += 1
num = floorl(num / baset)
if (num == 0):
break# loop AWAIT
for ii in range(dig_count, min_sz + 0, 1):
num2char_print(0)
for ii in range(dig_count - 1, -1, -1):
num2char_print(digits_arr[ii])
return int(min_sz)
def base_outf_print(num, baset):
dig_count = 0
if (num < 0.0):
print("-", end='')
num = -num
dig_count += 1
dig_count += base_out_print(floorl(num), baset) + 1
print(".", end='')
lim = ceill(-lg(DBLEPS) / lg(baset))
frc = frac(num) * baset
ii = 1
while (ii <= lim and not iszero(frc)):
dig = floorl(frc)
num2char_print(dig)
frc -= dig
frc *= baset
ii += 1
return int(dig_count + lim)
def fvoa(payment, rate_per_paymt, num_pays):
ttp = math.pow(1.0 + rate_per_paymt, num_pays)
return (payment * (ttp - 1.0) / rate_per_paymt)
def fvad(payment, rate_per_paymt, num_pays):
return (fvoa(payment, rate_per_paymt, num_pays) * (1.0 + rate_per_paymt))
def pvoa(payment, rate_per_paymt, num_pays):
ntp = math.pow(1.0 + rate_per_paymt, - num_pays)
return (payment * (1.0 - ntp) / rate_per_paymt)
def pvad(payment, rate_per_paymt, num_pays):
ntp = math.pow(1.0 + rate_per_paymt, - num_pays)
return (payment * (1.0 - ntp) / rate_per_paymt * (1.0 + rate_per_paymt))
def loanvalue(payment, rate_per_paymt, num_pays):
return (fvad(payment, rate_per_paymt, num_pays))
def loanpayment(loan_amt, rate_per_paymt, num_pays):
ttp = math.pow(1.0 + rate_per_paymt, num_pays)
return (loan_amt * rate_per_paymt * ttp / (ttp - 1.0))
def loanrate(loan_amt, payment, num_pays):
scvx_dx = 0.01
scvx_xx = 0.05
scvx_yy = payment - loanpayment(loan_amt, scvx_xx, num_pays)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = payment - loanpayment(loan_amt, scvx_xx, num_pays)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def f21(aa, bb, cc, zz):
if (1 < math.fabs(zz)):
sum_curr = 0.0
else:
sum_curr = 1.0
term = 1.0
nn = 0
while True:
term *= ((aa + nn) * (bb + nn) * zz / ((cc + nn) * (1 + nn)))
sum_prev = sum_curr
sum_curr += term
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
nn += 1
return (sum_curr)
def f11(aa, bb, zz):
if (1 < math.fabs(zz)):
sum_curr = 0.0
else:
sum_curr = 1.0
term = 1.0
nn = 0
while True:
term *= ((aa + nn) * zz / ((bb + nn) * (1 + nn)))
sum_prev = sum_curr
sum_curr += term
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
nn += 1
return (sum_curr)
def lf_lambert_iter(xx, nearw_zero):
wjj = nearw_zero
ii = 0
while True:
eww = math.exp(wjj)
tnn = wjj * eww - xx
snn = (wjj + 2.0) / (2.0 * (wjj + 1.0))
unn = (wjj + 1.0) * eww
delta = tnn / (tnn * snn - unn)
wjj_prev = wjj
wjj += delta
if (iseq(wjj, wjj_prev)):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
return (wjj)
def wp(xx):
if (xx <= - math.exp(-1.0)):
retvalu = -1.0
else:
if (xx < 3.0):
snn = E * xx + 1.0
near_w = cbrt(snn) - 1.0 + 0.025 * (snn / E)
else:
snn = math.log(xx)
tnn = math.log(math.log(xx))
near_w = snn - tnn + tnn / snn
retvalu = lf_lambert_iter(xx, near_w)
return (retvalu)
def wm(xx):
if (xx <= - math.exp(-1.0)):
retvalu = -1.0
else:
if (xx < - 0.303):
tnn = -math.sqrt(2.0 * (1.0 + E * xx))
near_w = ((((((((((226287557.0 / 37623398400.0) * tnn - 1963.0 /\
204120.0) * tnn + 680863.0 / 43545600.0) * tnn - 221.0\
/ 8505.0) * tnn + 769.0 / 17280.0) * tnn - 43.0 /\
540.0) * tnn + 11.0 / 72.0) * tnn - 1.0 / 3.0) * tnn +\
1.0) * tnn - 1.0)
elif (xx < - 0.0510129):
numer = (((6.5794931769023040E+2) * xx + 2.5388810188892484E+2)\
* xx - 7.8141767239074400)
denom = ((((((1.4779341280760887E+3) * xx +\
9.6217849696986600E+2) * xx + 6.8260739999094280E+2) *\
xx + 9.9985670831076100E+1) * xx -\
6.0439587136908080E+1) * xx + 1.0)
near_w = numer / denom
elif (xx < 0.0):
near_w = math.log(-xx)
for ii in range(0, 9, 1):
near_w = math.log(xx / near_w)
else:
near_w = DBLMAX
retvalu = lf_lambert_iter(xx, near_w)
return (retvalu)
def wpinv(zz):
return (zz * math.exp(zz))
def wminv(zz):
return (zz * math.exp(zz))
def sinintegral(xx):
if (iszero(xx)):
sum_curr = 0.0
else:
sum_curr = xx
term = xx
xsq = xx * xx
kk = 3
while True:
term *= - xsq / (kk * (kk - 1.0))
sum_prev = sum_curr
sum_curr += term / kk
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
kk += 2
return (sum_curr)
def cosintegral(xx):
if (iszero(xx)):
sum_curr = -DBLMAX
else:
sum_curr = EULER + math.log(math.fabs(xx))
term = 1.0
xsq = xx * xx
kk = 2
while True:
term *= - xsq / (kk * (kk - 1.0))
sum_prev = sum_curr
sum_curr += term / kk
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
kk += 2
return (sum_curr)
def Ein(xx):
sum_curr = 0
term = -1
kk = 1
while True:
term *= - xx / kk
sum_prev = sum_curr
sum_curr += term / kk
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
kk += 1
return (sum_curr)
def expintegrali(xx):
retvalu = EULER + math.log(math.fabs(xx)) - Ein(-xx)
return (retvalu)
def expintegral1(xx):
retvalu = Ein(xx) - EULER - math.log(math.fabs(xx))
return (retvalu)
def expintegraln(nn, xx):
return (math.pow(xx, nn - 1) * uigamma(1 - nn, xx))
def logintegral(xx):
if (xx <= 1.0):
retvalu = 0.0
else:
lnx = math.log(xx)
sum = 0.0
yy = 1.0
limit = 1.6 * math.log(xx) + 40
nn = 1
while True:
yy *= lnx / nn
sum_prev = sum
sum += yy / nn
if (iseq(sum, sum_prev)):
break# loop AWAIT
nn += 1
if (limit <= nn):
break# loop AWAIT
retvalu = EULER + math.log(lnx) + sum
return (retvalu)
def carlsonRF(xx, yy, zz):
while True:
sqx = math.sqrt(xx)
sqy = math.sqrt(yy)
sqz = math.sqrt(zz)
lmbd = sqx * sqy + sqx * sqz + sqy * sqz
xx = (xx + lmbd) / 4.0
yy = (yy + lmbd) / 4.0
zz = (zz + lmbd) / 4.0
if (iseq(xx, yy) and iseq(yy, zz)):
break# loop AWAIT
return (1.0 / math.sqrt(xx))
def carlsonRC(xx, yy):
while True:
lmbd = 2 * math.sqrt(xx * yy) + yy
xx = (xx + lmbd) / 4.0
yy = (yy + lmbd) / 4.0
if (iseq(xx, yy)):
break# loop AWAIT
return (1.0 / math.sqrt(xx))
def carlsonRJ(xx, yy, zz, pp):
pfour = 1.0
sigm = 0.0
while True:
sqx = math.sqrt(xx)
sqy = math.sqrt(yy)
sqz = math.sqrt(zz)
lmbd = sqx * sqy + sqx * sqz + sqy * sqz
alfa = pp * (sqx + sqy + sqz) + sqx * sqy * sqz
alfa *= alfa
beta = pp * (pp + lmbd) * (pp + lmbd)
sigm += pfour * carlsonRC(alfa, beta)
pfour /= 4.0
xx = (xx + lmbd) / 4.0
yy = (yy + lmbd) / 4.0
zz = (zz + lmbd) / 4.0
pp = (pp + lmbd) / 4.0
if (iseq(xx, yy) and iseq(yy, zz) and iseq(zz, pp)):
break# loop AWAIT
return (3.0 * sigm)
def carlsonRD(xx, yy, zz):
pfour = 1.0
sigm = 0.0
while True:
sqx = math.sqrt(xx)
sqy = math.sqrt(yy)
sqz = math.sqrt(zz)
lmbd = sqx * sqy + sqx * sqz + sqy * sqz
alfa = zz * (sqx + sqy + sqz) + sqx * sqy * sqz
alfa *= alfa
beta = zz * (zz + lmbd) * (zz + lmbd)
sigm += pfour * carlsonRC(alfa, beta)
pfour /= 4.0
xx = (xx + lmbd) / 4.0
yy = (yy + lmbd) / 4.0
zz = (zz + lmbd) / 4.0
if (iseq(xx, yy) and iseq(yy, zz)):
break# loop AWAIT
return (3.0 * sigm)
def powi(xx, nn):
pp = 1
xsq = xx
while (0 < nn):
if (isodd(nn)):
pp *= xsq
xsq *= xsq
nn = (nn >> 1)
return int(pp)
def atothenmodp(naa, nn, pp):
if (pp == 0):
retvalu = 0
else:
if (pp < 0):
pp = -pp
if (nn < 0):
nn = nn % pp
if (nn < 0):
nn += pp
retvalu = 1
cc = naa % pp
while (0 < nn):
if (isodd(nn)):
retvalu = (retvalu * cc) % pp
nn = (nn - 1) / 2
else:
nn /= 2
cc = (cc * cc) % pp
return int(retvalu)
def atothenmodx(xaa, xnn, xpp):
return (frac(math.exp(xnn * math.log(xaa) - math.log(xpp))) * xpp)
def ctz(nn):
zero_count = 0
while (0 == (nn & 1)):
zero_count += 1
nn = (nn >> 1)
return int(zero_count)
def gcd(naa, nbb):
naa = math.fabs(naa)
nbb = math.fabs(nbb)
if (nbb <= 0):
nbb = naa
else:
while (0 < naa):
cc = naa
naa = nbb % naa
nbb = cc
return int(nbb)
def gcda(array_count, num_arr_pc):
gc = num_arr_pc[0]
for ind in range(1, array_count + 0, 1):
gc = gcd(gc, num_arr_pc[ind])
return int(gc)
def lcm(naa, nbb):
return int((naa * nbb / gcd(naa, nbb)))
def lcam(naa, nbb):
if (nbb < naa):
ii = naa
naa = nbb
nbb = ii
ii = nbb
while True:
jj = mods(ii, naa)
if (- 2 <= jj and jj <= 2):
break# loop AWAIT
ii += nbb
if (jj == -2):
ii += 1
elif (0 <= jj):
ii -= 1
return int(ii)
def lcams(naa, nbb):
if (nbb < naa):
ii = naa
naa = nbb
nbb = ii
ii = 2 * nbb
while True:
jj = mods(ii, naa)
if (- 2 <= jj and jj <= 2):
break# loop AWAIT
ii += nbb
if (jj == -2):
ii += 1
elif (0 <= jj):
ii -= 1
return int(ii)
def lcantim(naa, nbb):
if (isposint(naa) and isposint(nbb)):
odd_mask = 0
if (isodd(naa)):
odd_mask = 1
if (isodd(nbb)):
odd_mask += 2
if (2 == odd_mask or (nbb < naa and odd_mask != 1)):
ii = nbb
nbb = naa
naa = ii
hnaa = floorl(naa / 2)
hnbb = floorl(nbb / 2)
ii = hnbb
while True:
rema = dist(ii, naa)
if (rema == hnaa):
break
elif (odd_mask == 3 and rema == hnaa + 1):
break
ii += nbb
if (naa * nbb <= ii):
break# loop AWAIT
if (naa * nbb <= ii):
ii = 0
else:
ii = 0
return int(ii)
def factor(number_to_factor, ret_fctr_arr_p):
fctr_ind = 0
number_to_factor = math.fabs(number_to_factor)
if (number_to_factor <= 3):
ret_fctr_arr_p[fctr_ind] = number_to_factor
fctr_ind = 1
else:
for pp in range(2, 4, 1):
while (0 == number_to_factor % pp):
ret_fctr_arr_p[fctr_ind] = pp
fctr_ind += 1
number_to_factor /= pp
pp = 1
inc = 4
while True:
pp += inc
inc = 6 - inc
while (0 == number_to_factor % pp):
ret_fctr_arr_p[fctr_ind] = pp
fctr_ind += 1
number_to_factor /= pp
if (number_to_factor < pp * pp):
break# loop AWAIT
if (1 < number_to_factor):
ret_fctr_arr_p[fctr_ind] = number_to_factor
fctr_ind += 1
ret_fctr_arr_p[fctr_ind] = 0
return int(fctr_ind)
def modulo(nxx, modyy):
retvalu = nxx % modyy
if (retvalu < 0):
retvalu += math.fabs(modyy)
return int(retvalu)
def mods(nxx, modyy):
amodyy = floorl(math.fabs(modyy))
anxx = math.fabs(nxx)
retvalu = anxx % amodyy
if (0 < retvalu):
while (amodyy < 2 * retvalu):
retvalu -= amodyy
elif (retvalu < 0):
while (2 * retvalu < - amodyy):
retvalu += amodyy
return int(retvalu)
def pfl(nn):
if (nn < 2):
small_factor = 1
elif (nn % 2 == 0):
small_factor = 2
elif (nn % 3 == 0):
small_factor = 3
elif (nn % 5 == 0):
small_factor = 5
elif (nn % 7 == 0):
small_factor = 7
else:
lim = floorl(math.sqrt(nn))
divid = 11
small_factor = nn
while (divid <= lim):
if (nn % divid == 0):
small_factor = divid
break
divid += 2
if (nn % divid == 0):
small_factor = divid
break
divid += 4
return int(small_factor)
def pfg(nn):
jj = nn
while True:
ii = pfl(jj)
jj /= ii
if (jj == 1):
break# loop AWAIT
return int(ii)
def isprime(nn):
ann = math.fabs(nn)
if (ann == 2 or ann == 3 or ann == 5 or ann == 7):
retvalu_bol = True
elif (ann < 11):
retvalu_bol = False
elif (pfl(ann) == ann):
retvalu_bol = True
else:
retvalu_bol = False
return (retvalu_bol)
def lf_primeprev(pp):
if (pp <= 7):
if (5 < pp):
retvalu = 5
elif (3 < pp):
retvalu = 3
elif (2 < pp):
retvalu = 2
else:
retvalu = -2
else:
rema = pp % 6
qq = pp - rema
if (rema <= 1):
qq -= 1
inc = 4
else:
qq += 1
inc = 2
while (not isprime(qq)):
qq -= inc
inc = 6 - inc
retvalu = qq
return int(retvalu)
def lf_primenext(pp):
if (pp < 7):
if (pp < 2):
retvalu = 2
elif (pp < 3):
retvalu = 3
elif (pp < 5):
retvalu = 5
else:
retvalu = 7
else:
rema = (pp + 1) % 6
qq = (pp + 1) - rema
if (rema <= 1):
qq += 1
inc = 4
else:
qq += 5
inc = 2
while (not isprime(qq)):
qq += inc
inc = 6 - inc
retvalu = qq
return int(retvalu)
def primeprev(pp):
if (0 <= pp):
retvalu = lf_primeprev(pp)
else:
retvalu = -lf_primenext(-pp)
return int(retvalu)
def primenext(pp):
if (0 <= pp):
retvalu = lf_primenext(pp)
else:
retvalu = -lf_primeprev(-pp)
return int(retvalu)
lv_pcf_end = 0
lv_pcf_arr = [0 for ii in range(0)]
def primecount(xx):
global lv_pcf_arr
global lv_pcf_end
if (xx < 7):
if (xx < 3):
if (xx < 2):
retvalu = 0
else:
retvalu = 1
else:
if (xx < 5):
retvalu = 2
else:
retvalu = 3
else:
s_ind = floorl((xx - 5) / 2) - floorl((xx - 3) / 6)
if (lv_pcf_end <= s_ind):
ps_ind = lv_pcf_end
if (lv_pcf_end <= 0):
pcf_val = 2
else:
pcf_val = lv_pcf_arr[lv_pcf_end - 1]
lv_pcf_end = ceil2(s_ind + 1, 2)
for nzzn in range(len(lv_pcf_arr), int(lv_pcf_end)):
lv_pcf_arr.append(0)
poss_prime = 3 * ps_ind - (ps_ind % 2) + 5
while (ps_ind <= s_ind):
if (isprime(poss_prime)):
pcf_val += 1
lv_pcf_arr[ps_ind] = pcf_val
poss_prime += 2
ps_ind += 1
if (isprime(poss_prime)):
pcf_val += 1
lv_pcf_arr[ps_ind] = pcf_val
poss_prime += 4
ps_ind += 1
retvalu = lv_pcf_arr[s_ind]
return int(retvalu)
def pcf(xx):
return int((primecount(xx)))
def primecountx(xx):
if (xx < 7):
if (xx < 3):
if (xx < 2):
retvalu = 0
else:
retvalu = 1
else:
if (xx < 5):
retvalu = 2
else:
retvalu = 3
else:
pcf_val = 4
poss_prime = 11
inc = 2
while (poss_prime <= xx):
if (isprime(poss_prime)):
pcf_val += 1
poss_prime += inc
inc = 6 - inc
retvalu = pcf_val
return int(retvalu)
def eta(xx):
ps_arr = []
temp_arr = []
if (0 < xx):
tt = 0
term = -math.log(DBLEPS) / xx
if (term < math.log(4000)):
kk = ceill(math.exp(term))
sum = 0
pm_one = -1.0
nn = 1
while True:
pm_one = -pm_one
term = pm_one * math.pow(nn, - xx)
tt += 1
sump = sum
sum += term
if (iseq(sump, sum)):
break# loop AWAIT
nn += 1
if (kk <= nn):
break# loop AWAIT
retvalu = sum - 0.5 * term
else:
sum = 0
pm_one = -1.0
for nzzn in range(len(ps_arr), int(402)):
ps_arr.append(0)
for nzzn in range(len(temp_arr), int(402)):
temp_arr.append(0)
ps_arr[0] = -math.pow(2, - xx)
tt += 1
temp_arr[0] = ps_arr[0]
nn = 1
while True:
pm_one = -pm_one
ps_arr[nn] = ps_arr[nn - 1] + pm_one * math.pow(nn + 2, - xx)
tt += 1
temp_arr[nn] = ps_arr[nn]
for kk in range(nn - 1, -1, -1):
temp_arr[kk] = (temp_arr[kk] + temp_arr[kk + 1]) / 2.0
sump = sum
sum = temp_arr[0]
if (iseq(sump, sum)):
break# loop AWAIT
nn += 1
if (400 <= nn):
break# loop AWAIT
s_ind = floorl(nn / 3)
sum = (4 * temp_arr[s_ind] + 3 * temp_arr[s_ind + 1]) / 7
retvalu = sum + 1.0
elif (xx < 0):
retvalu = 0.0
else:
retvalu = 0.5
return (retvalu)
def zeta(xx):
if (1 < xx):
retvalu = eta(xx) / (1.0 - math.pow(2.0, 1.0 - xx))
else:
retvalu = 0.0
return (retvalu)
def fibo3(nn, fib_a, fib_b):
if (nn == 0):
retvalu = fib_a
else:
for ii in range(2, nn + 1, 1):
tt = fib_b
fib_b += fib_a
fib_a = tt
retvalu = fib_b
return (retvalu)
def fibo(nn):
return (fibo3(nn, 0, 1))
def fibox(xx):
if (math.log(DBLMAX) / math.log(PHI) < math.fabs(xx)):
retvalu = 0.0
else:
zz = math.pow(PHI, xx)
retvalu = (zz - math.cos(PI * xx) / zz) / math.sqrt(5.0)
return (retvalu)
def fiboxinv(yy):
if (yy <= 0):
scvx_xx = 0.0
else:
if (yy <= 0.2):
x_init = 0.075
elif (yy <= 0.896946387424606):
x_init = 0.8 * yy - 0.15
elif (yy <= 1.009824331847821):
x_init = 0.92
else:
x_init = math.log(yy * math.sqrt(5.0)) / math.log(PHI)
scvx_dx = 0.05
scvx_xx = x_init
scvx_yy = yy - fibox(scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = yy - fibox(scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def lucas(nn):
return (fibo3(nn, 2, 1))
def lucasx(xx):
if (math.log(DBLMAX) / math.log(PHI) < math.fabs(xx)):
retvalu = 0.0
else:
zz = math.pow(PHI, xx)
retvalu = (zz + math.cos(PI * xx) / zz)
return (retvalu)
def fusc(nn):
naa = 1
nbb = 0
while (0 < nn):
if (isodd(nn)):
nbb += naa
else:
naa += nbb
nn = (nn >> 1)
return int(nbb)
def Tn(nn, xx):
if (nn == 0):
retvalu = 1.0
elif (nn == 1):
retvalu = xx
elif (nn == 2):
retvalu = 2.0 * xx * xx - 1.0
else:
tnm_a = 2.0 * xx * xx - 1.0
tnm_b = xx
tnn = tnm_a
for kk in range(3, nn + 1, 1):
tnn = (2.0 * xx * tnm_a) - tnm_b
tnm_b = tnm_a
tnm_a = tnn
retvalu = tnn
return (retvalu)
def Un(nn, xx):
if (nn == 0):
retvalu = 1.0
elif (nn == 1):
retvalu = 2.0 * xx
else:
tnm_a = 2.0 * xx
tnm_b = 1.0
tnn = tnm_a
for kk in range(2, nn + 1, 1):
tnn = (2.0 * xx * tnm_a) - tnm_b
tnm_b = tnm_a
tnm_a = tnn
retvalu = tnn
return (retvalu)
def tri(nn):
return (nn * (nn + 1) / 2)
def triinv(nn):
if (- 0.125 < nn):
retvalu = (math.sqrt(8.0 * nn + 1.0) - 1.0) / 2.0
else:
retvalu = -0.5
return (retvalu)
def polynum(ss, nn):
return ((ss - 2) * nn * (nn - 1) / 2 + nn)
def polycnum(ss, nn):
return (ss * nn * (nn - 1) / 2 + 1)
def tetranum(ss, nn):
return (nn * (nn + 1) * ((ss - 2) * nn + 5 - ss) / 6)
def tetracnum(ss, nn):
return (nn * (ss * nn * nn + 6 - ss) / 6)
def minkowski(xx):
pp = floor(xx)
qq = 1
rr = pp + 1
ss = 1
dd = 1.0
yy = pp
while True:
dd /= 2.0
ff = pp + rr
gg = qq + ss
if (xx < ff / gg):
rr = ff
ss = gg
else:
yy += dd
pp = ff
qq = gg
if (iseq(yy + dd, yy)):
break# loop AWAIT
return (yy)
def cantorxx(nbb, ee, xx):
if (ee < 0.0 or nbb < 0.0 or 1.0 < ee + nbb):
yy = xx
else:
ulmt = 1.0 - ee
yy = floor(xx)
rest = (xx - yy)
dd = 0.5
while True:
if (ulmt <= rest):
yy += dd
rest = frac((rest - ulmt) / ee)
elif (nbb <= rest):
yy += dd
break
else:
rest = frac(rest / nbb)
dd /= 2.0
if (iseq(yy + dd, yy) or iszero(rest)):
break# loop AWAIT
return (yy)
def cantor(xx):
return (cantorxx(1.0 / 3.0, 1.0 / 3.0, xx))
def cantorul(bb, ee, xx):
return (math.pow(0.5, math.log(xx) / math.log(bb) + 0.0 * ee))
def cantorll(bb, ee, xx):
return (math.pow(0.5, math.log(xx / (1.0 - ee)) / math.log(bb) + 1.0))
def dlogx(naa, nbb, nn):
pp = naa
retvalu = -1
for ii in range(1, nn + 1, 1):
if (pp == nbb):
retvalu = ii
break
pp = (pp * naa) % nn
return int(retvalu)
def dlog(naa, nbb, nn):
log_arr = []
if (naa == nbb):
retvalu = 1
elif (naa <= 0 or nbb <= 0 or nn <= 0):
retvalu = -1
elif (1 < gcd(naa, nn)):
retvalu = dlogx(naa, nbb, nn)
elif (not isprimitiveroot(naa, nn)):
retvalu = dlogx(naa, nbb, nn)
else:
sqnn = ceill(math.sqrt(nn))
for nzzn in range(len(log_arr), int(nn)):
log_arr.append(0)
for ii in range(0, nn + 0, 1):
log_arr[ii] = 0
atothesqnn = atothenmodp(naa, sqnn, nn)
cur = atothesqnn
for ii in range(1, sqnn + 1, 1):
if (log_arr[cur] == 0):
log_arr[cur] = ii
cur = (cur * atothesqnn) % nn
cur = nbb % nn
retvalu = -1
for ii in range(0, sqnn + 1, 1):
if (0 < log_arr[cur]):
atothens = log_arr[cur] * sqnn - ii
if (atothens < nn):
retvalu = atothens
break
cur = (cur * naa) % nn
return int(retvalu)
def dlog1(naa, nn):
return int((dlog(naa, 1, nn)))
lv_mertens_end = 0
lv_mertens_arr = [0 for ii in range(0)]
def mertens(nn):
global lv_mertens_arr
global lv_mertens_end
if (nn < 0):
retvalu = 0
else:
if (lv_mertens_end <= 0):
lv_mertens_end = 4
for nzzn in range(len(lv_mertens_arr), int(lv_mertens_end)):
lv_mertens_arr.append(0)
lv_mertens_arr[0] = 0
lv_mertens_arr[1] = 1
lv_mertens_arr[2] = 0
lv_mertens_arr[3] = -1
if (lv_mertens_end <= nn):
kk = lv_mertens_end
lv_mertens_end = nn + 1
for nzzn in range(len(lv_mertens_arr), int(lv_mertens_end)):
lv_mertens_arr.append(0)
while (kk < lv_mertens_end):
lv_mertens_arr[kk] = lv_mertens_arr[kk - 1] + mobius(kk)
kk += 1
retvalu = lv_mertens_arr[nn]
return int(retvalu)
def has_primitiveroot_f(array_size, fac_arr_pc):
ind = 0
if (1 < array_size):
if (fac_arr_pc[0] == 2):
ind += 1
if (2 < fac_arr_pc[ind]):
while (ind < array_size - 1):
if (fac_arr_pc[ind] < fac_arr_pc[ind + 1]):
break
ind += 1
return (ind == (array_size - 1))
def sigma0_f(array_size, fac_arr_pc):
retvalu = 1
exp_i = 2
for ind in range(0, array_size - 1, 1):
if (fac_arr_pc[ind] == fac_arr_pc[ind + 1]):
exp_i += 1
else:
retvalu *= exp_i
exp_i = 2
return int(retvalu * exp_i)
def sigma1_f(array_size, fac_arr_pc):
retvalu = 1
exp_i = 2
prm_prev = fac_arr_pc[0]
for ind in range(1, array_size + 0, 1):
prm_curr = fac_arr_pc[ind]
if (prm_prev == prm_curr):
exp_i += 1
else:
retvalu *= (powi(prm_prev, exp_i) - 1) / (prm_prev - 1)
exp_i = 2
prm_prev = prm_curr
return int((retvalu * (powi(prm_prev, exp_i) - 1) / (prm_prev - 1)))
def sigma_f(powy, array_size, fac_arr_pc):
if (powy == 0):
retvalu = sigma0_f(array_size, fac_arr_pc)
elif (powy == 1):
retvalu = sigma1_f(array_size, fac_arr_pc)
else:
retvalu = 1
exp_i = 2
prm_prev = fac_arr_pc[0]
for ind in range(1, array_size + 0, 1):
prm_curr = fac_arr_pc[ind]
if (prm_prev == prm_curr):
exp_i += 1
else:
pw = powi(prm_prev, powy)
retvalu *= ((powi(pw, exp_i) - 1) / (pw - 1))
exp_i = 2
prm_prev = prm_curr
pw = powi(prm_prev, powy)
retvalu *= ((powi(pw, exp_i) - 1) / (pw - 1))
return int(retvalu)
def ispractical_f(array_size, fac_arr_pc):
if (2 < fac_arr_pc[0]):
retvalu_bol = False
else:
retvalu_bol = True
sgma = 1
exp_i = 2
prm_prev = fac_arr_pc[0]
for ind in range(1, array_size + 0, 1):
prm_curr = fac_arr_pc[ind]
if (prm_prev == prm_curr):
exp_i += 1
else:
sgma *= (powi(prm_prev, exp_i) - 1) / (prm_prev - 1)
if (1 + sgma < prm_curr):
retvalu_bol = False
break
exp_i = 2
prm_prev = prm_curr
return (retvalu_bol)
def issquarefree_f(array_size, fac_arr_pc):
retvalu_bol = True
for ind in range(1, array_size + 0, 1):
if (fac_arr_pc[ind - 1] == fac_arr_pc[ind]):
retvalu_bol = False
break
return (retvalu_bol)
def totient_f(array_size, fac_arr_pc):
retvalu = 1
for ind in range(0, array_size - 1, 1):
if (fac_arr_pc[ind] == fac_arr_pc[ind + 1]):
retvalu *= fac_arr_pc[ind]
else:
retvalu *= (fac_arr_pc[ind] - 1)
retvalu *= (fac_arr_pc[array_size - 1] - 1)
return int(retvalu)
def mobius_f(array_size, fac_arr_pc):
if (iseven(array_size)):
retvalu = 1
else:
retvalu = -1
for ind in range(1, array_size + 0, 1):
if (fac_arr_pc[ind - 1] == fac_arr_pc[ind]):
retvalu = 0
break
return int(retvalu)
def prime0_f(array_size, fac_arr_pc):
retvalu = 1
prm_prev = fac_arr_pc[0]
for ind in range(1, array_size + 0, 1):
prm_curr = fac_arr_pc[ind]
if (prm_prev < prm_curr):
retvalu += 1
prm_prev = prm_curr
return int(retvalu)
LC_FACTORS_CNT = 65
def factor_print(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
array_size = factor(nn, fac_arr)
print(str(nn), end='')
print(":", end='')
for ind in range(0, array_size + 0, 1):
print(" ", end='')
print(str(fac_arr[ind]), end='')
print("\n", end='')
return int(array_size)
def mobius(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
array_size = factor(nn, fac_arr)
return int((mobius_f(array_size, fac_arr)))
def isprimitiveroot(naa, nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
if (naa <= 1 or 1 < gcd(naa, nn)):
retvalu_bol = False
elif (naa == 2):
retvalu_bol = isodd(nn)
else:
toti = totient(nn)
array_size_toti = factor(toti, fac_arr)
if (atothenmodp(naa, toti / fac_arr[0], nn) == 1):
retvalu_bol = False
else:
retvalu_bol = True
for ind in range(1, array_size_toti + 0, 1):
if (fac_arr[ind - 1] != fac_arr[ind]):
prm = fac_arr[ind]
if (atothenmodp(naa, toti / prm, nn) == 1):
retvalu_bol = False
break
return (retvalu_bol)
def prime0(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
array_size = factor(nn, fac_arr)
return int((prime0_f(array_size, fac_arr)))
def prime1(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
return int((factor(nn, fac_arr)))
def sigma0(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
array_size = factor(nn, fac_arr)
return int((sigma0_f(array_size, fac_arr)))
def sigma1(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
array_size = factor(nn, fac_arr)
return int((sigma1_f(array_size, fac_arr)))
def sigma(powy, nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
if (nn <= 1):
retvalu = nn
elif (powy == 0):
retvalu = sigma0(nn)
elif (powy == 1):
retvalu = sigma1(nn)
else:
array_size = factor(nn, fac_arr)
retvalu = sigma_f(powy, array_size, fac_arr)
return int(retvalu)
def totient(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
array_size = factor(nn, fac_arr)
return int((totient_f(array_size, fac_arr)))
def has_primitiveroot(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
if (nn < 2):
retvalu_bol = False
else:
array_size = factor(nn, fac_arr)
retvalu_bol = has_primitiveroot_f(array_size, fac_arr)
return (retvalu_bol)
def issquarefree(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
if (nn < 1):
retvalu_bol = False
elif (nn < 3):
retvalu_bol = True
else:
array_size = factor(nn, fac_arr)
retvalu_bol = issquarefree_f(array_size, fac_arr)
return (retvalu_bol)
def ispractical(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
if (nn < 1):
retvalu_bol = False
elif (nn < 3):
retvalu_bol = True
else:
array_size = factor(nn, fac_arr)
retvalu_bol = ispractical_f(array_size, fac_arr)
return (retvalu_bol)
def primitiveroot(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
if (nn < 2):
retvalu = 0
elif (nn < 5):
retvalu = nn - 1
elif (not has_primitiveroot(nn)):
retvalu = 0
else:
toti = totient(nn)
array_size_toti = factor(toti, fac_arr)
ii = 2
retvalu = 0
while (ii < nn and retvalu <= 0):
if (gcd(ii, nn) == 1):
retvalu = ii
prm = 0
for ind in range(0, array_size_toti + 0, 1):
if (prm != fac_arr[ind]):
prm = fac_arr[ind]
if (atothenmodp(ii, toti / prm, nn) == 1):
retvalu = 0
break
ii += 1
return int(retvalu)
def carmichael(nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
if (nn < 8):
lmbd = totient(nn)
else:
array_size = factor(nn, fac_arr)
ind = 0
while (ind < array_size and fac_arr[ind] == 2):
ind += 1
if (2 < ind):
lmbd = (1 << (ind - 2))
else:
lmbd = 1
while (ind < array_size):
prm = fac_arr[ind]
pk = prm - 1
while (ind < array_size - 1 and prm == fac_arr[ind + 1]):
ind += 1
pk *= prm
lmbd = lcm(lmbd, pk)
ind += 1
return int(lmbd)
def znorder(naa, nn):
fac_arr = [0 for ii in range(LC_FACTORS_CNT)]
if (nn == 0 or naa == 0):
kk = 0
else:
if (nn < 0):
nn = -nn
while (naa < 0):
naa += nn
if (nn <= 1):
kk = nn
elif (naa <= 1):
kk = naa
elif (1 < gcd(naa, nn)):
kk = 0
else:
kk = carmichael(nn)
array_sizekk = factor(kk, fac_arr)
exp_i = 1
for ind in range(0, array_sizekk + 0, 1):
prm_i = fac_arr[ind]
kk /= prm_i
if (ind + 1 < array_sizekk and prm_i == fac_arr[ind + 1]):
exp_i += 1
else:
ab = atothenmodp(naa, kk, nn)
for ek in range(0, exp_i + 1, 1):
if (ab == 1):
break
kk *= prm_i
ab = atothenmodp(ab, prm_i, nn)
if (exp_i < ek):
kk = 0
break
exp_i = 1
return int(kk)
def repetendlen(denm, basee):
while True:
gdn = gcd(denm, basee)
denm /= gdn
if (1 == gdn):
break# loop AWAIT
if (denm == 1):
retvalu = 0
else:
retvalu = znorder(basee, denm)
return int(retvalu)
def kevy_print(den, start, basee):
log_start = floorl(math.log(start) / math.log(basee) + 1)
baseek = math.pow(basee, log_start)
overall_len = (dlog(basee, den, den * baseek - 1) + 3) * log_start
leny = 0
numer = start
valu = start
while True:
base_out_fix_print(valu, basee, log_start)
leny += log_start
valu = floorl(numer / den)
rema = numer % den
numer = rema * baseek + valu
if (numer == start):
break
if (2 * overall_len < leny):
break# loop AWAIT
return int(leny)
def eulerphi(nn):
return int((totient(nn)))
def znorder__1(nbb, mdls):
if (1 < gcd(nbb, mdls)):
nn = 0
else:
pp = 1
nn = 1
while True:
pp = (pp * nbb) % mdls
if (pp == 1):
break# loop AWAIT
nn += 1
if (mdls <= nn):
break# loop AWAIT
return int(nn)
def bkn(nbb, kk):
return int((znorder(nbb, kk * nbb - 1)))
def bkbn(nbb, kk, cc):
mdls = kk * nbb - 1
if (mdls % cc == 0):
mdls /= cc
return int((znorder(nbb, mdls)))
lv_li_two = 0
def lix(xx):
global lv_li_two
if (lv_li_two <= 0):
lv_li_two = logintegral(2.0)
return (logintegral(xx) - lv_li_two)
def lixinv(yy):
x_init = yy / math.log(yy)
scvx_dx = 0.05
scvx_xx = x_init
scvx_yy = yy - lix(scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = yy - lix(scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def lf_n2primish(nn):
if (nn == 0):
retvalu = 0
elif (nn < 3):
retvalu = nn + 1
elif (isodd(nn)):
retvalu = 3 * nn - 4
else:
retvalu = 3 * nn - 5
return int(retvalu)
def n2primish(nn):
if (0 < nn):
retvalu = lf_n2primish(nn)
else:
retvalu = -lf_n2primish(-nn)
return int(retvalu)
def primenth__1(nn):
if (nn < 0):
retvalu = 0
elif (nn < 4.25):
retvalu = 1.6 * nn + 0.1
else:
logn = math.log(nn)
loglogn = math.log(logn)
retvalu = nn * (logn + loglogn - 1.0 + (loglogn - 2.0) / logn -\
((loglogn - 6.0) * loglogn + 11.0) / (2.0 * logn * logn))\
+ 3.5 * math.sqrt(nn) + 10
return (retvalu)
def reimann(nn):
if (nn < 2):
retvalu = 0
else:
sum = lix(nn)
lim = 10 * lg(nn)
ii = 2
while True:
sum_prev = sum
sum += mobius(ii) * lix(math.pow(nn, 1.0 / ii)) / ii
if (iseq(sum, sum_prev)):
break# loop AWAIT
ii += 1
if (lim <= ii):
break# loop AWAIT
retvalu = sum
return (retvalu)
def primenth(nn):
prime_arr = [0 for ii in range(30)]
if (nn < 5):
if (nn < 1):
pp = 0
elif (nn < 2):
pp = 2
elif (nn < 3):
pp = 3
elif (nn < 4):
pp = 5
else:
pp = 7
else:
if (1024 <= nn):
prime_arr[0] = 8161
prime_arr[1] = 17863
prime_arr[2] = 38873
prime_arr[3] = 84017
prime_arr[4] = 180503
prime_arr[5] = 386093
prime_arr[6] = 821641
prime_arr[7] = 1742537
prime_arr[8] = 3681131
prime_arr[9] = 7754077
prime_arr[10] = 16290047
prime_arr[11] = 34136029
prime_arr[12] = 71378569
prime_arr[13] = 148948139
prime_arr[14] = 310248241
prime_arr[15] = 645155197
prime_arr[16] = 1339484197
prime_arr[17] = 2777105129
prime_arr[18] = 5750079047
prime_arr[19] = 11891268401
prime_arr[20] = 24563311309
prime_arr[21] = 50685770167
prime_arr[22] = 104484802057
ii = floorl(lg(nn + 1) - 10)
if (22 <= ii):
ii = 22
pp = prime_arr[ii]
ii = round(math.pow(2, ii + 10))
rmndr = fmodu(pp, 6)
if (iseq(rmndr, 5)):
inc = 2
elif (iseq(rmndr, 1)):
inc = 4
else:
sys.stderr.write("primenth:" + "PRIME_ISNT_PM_1_MOD_6")
sys.exit(1)
else:
pp = 11
ii = 5
inc = 2
while (ii < nn):
while True:
pp += inc
inc = 6 - inc
if (isprime(pp)):
break# loop AWAIT
ii += 1
return int(pp)
def bessJv(vv, xx):
if (xx < 0.0):
sum = 0.0
else:
avv = vv
if (isposint(-vv)):
avv = math.fabs(vv)
xxsqr_div_four = (xx * xx / 4.0)
term = math.pow(xx / 2.0, avv) / tgamma(avv + 1.0)
sum = term
ff = 1
while True:
term *= - xxsqr_div_four / (ff * (avv + ff))
sum_prev = sum
sum += term
if (iseq(sum, sum_prev)):
break# loop AWAIT
ff += 1
if (isposint(-vv) and isodd(vv)):
sum = -sum
return (sum)
def bessYv(vv, xx):
if (isint(vv)):
retvalu = bessYn(vv, xx)
else:
vvpi = PI * vv
retvalu = (math.cos(vvpi) * bessJv(vv, xx) - bessJv(-vv, xx)) /\
math.sin(vvpi)
return (retvalu)
def bessI0(xx):
if (xx < 7.75):
yy = xx * xx / 4.0
retvalu = (((((((((((((((((1.1497640034400735733456400E-29) * yy +\
2.0732014503197852176921968E-27) * yy +\
5.9203280572170548134753422E-25) * yy +\
1.3141332422663039834197910E-22) * yy +\
2.5791926805873898803749321E-20) * yy +\
4.3583591008893599099577755E-18) * yy +\
6.2760839879536225394314453E-16) * yy +\
7.5940582595094190098755663E-14) * yy +\
7.5940584360755226536109511E-12) * yy +\
6.1511873265092916275099070E-10) * yy +\
3.9367598891475388547279760E-8) * yy +\
1.9290123456788994104574754E-6) * yy +\
6.9444444444444568581891535E-5) * yy +\
1.7361111111111110294015271E-3) * yy +\
2.7777777777777777805664954E-2) * yy +\
2.4999999999999999999629693E-1) * yy +\
1.0000000000000000000000801) * yy + 1.0
else:
yy = 1.0 / xx
retvalu = (((((((((((((((((((((((1.6069467093441596329340754E+16) *\
yy - 2.1363029690365351606041265E+16) * yy +\
1.3012646806421079076251950E+16) * yy -\
4.8049082153027457378879746E+15) * yy +\
1.1989242681178569338129044E+15) * yy -\
2.1323049786724612220362154E+14) * yy +\
2.7752144774934763122129261E+13) * yy -\
2.6632742974569782078420204E+12) * yy +\
1.8592340458074104721496236E+11) * yy -\
8.9270060370015930749184222E+9) * yy +\
2.3518420447411254516178388E+8) * yy +\
2.6092888649549172879282592E+6) * yy -\
5.9355022509673600842060002E+5) * yy +\
3.1275740782277570164423916E+4) * yy -\
1.0026890180180668595066918E+3) * yy +\
2.2725199603010833194037016E+1) * yy -\
1.0699095472110916094973951E-1) * yy +\
9.4085204199017869159183831E-2) * yy +\
4.4718622769244715693031735E-2) * yy +\
2.9219501690198775910219311E-2) * yy +\
2.8050628884163787533196746E-2) * yy +\
4.9867785050353992900698488E-2) * yy +\
3.9894228040143265335649948E-1)
retvalu *= math.exp(xx) / math.sqrt(xx)
return (retvalu)
def bessI1(xx):
if (xx < 7.75):
yy = xx * xx / 4.0
aa = (((((((((((((1.332898928162290861E-23) * yy +\
1.625212890947171108E-21) * yy + 3.410720494727771276E-19)\
* yy + 5.220157095351373194E-17) * yy +\
6.904822652741917551E-15) * yy + 7.593969849687574339E-13)\
* yy + 6.834657311305621830E-11) * yy +\
4.920949692800671435E-9) * yy + 2.755731926254790268E-7) *\
yy + 1.157407407354987232E-5) * yy +\
3.472222222225921045E-4) * yy + 6.944444444444341983E-3) *\
yy + 8.333333333333333803E-2)
retvalu = ((aa * yy + 0.5) * yy + 1.0) * xx / 2.0
elif (xx < 500.0):
yy = 1.0 / xx
retvalu = ((((((((((((((((((((((-2.213318202179221945E+15) * yy +\
3.146401654361325073E+15) * yy - 2.067285045778906105E+15)\
* yy + 8.325554073334618015E+14) * yy -\
2.298849639457172489E+14) * yy + 4.614040809616582764E+13)\
* yy - 6.967602516005787001E+12) * yy +\
8.087824484994859552E+11) * yy - 7.313784438967834057E+10)\
* yy + 5.192386898222206474E+9) * yy -\
2.903390398236656519E+8) * yy + 1.277677779341446497E+7) *\
yy - 4.404655582443487334E+5) * yy +\
1.178785865993440669E+4) * yy - 2.426181371595021021E+2) *\
yy + 3.458284470977172076) * yy - 1.528189554374492735E-1)\
* yy - 5.719036414430205390E-2) * yy -\
4.090895951581637791E-2) * yy - 4.675104253598537322E-2) *\
yy - 1.496033551613111533E-1) * yy +\
3.989422804014406054E-1) * math.exp(xx) / math.sqrt(xx)
else:
yy = 1.0 / xx
aa = math.exp(xx / 2.0)
retvalu = (((((-5.843630344778927582E-2) * yy -\
4.090421597376992892E-2) * yy - 4.675105322571775911E-2) *\
yy - 1.496033551467584157E-1) * yy +\
3.989422804014314820E-1) * aa / math.sqrt(xx)
retvalu *= aa
return (retvalu)
def bessK0(arg):
xx = arg
if (xx <= 0.0):
retvalu = DBLMAX
elif (xx < DBLEPS):
retvalu = 0.11593151565841244858684731328185 - math.log(xx)
elif (xx <= 1.0):
xz = xx * xx
sump = (((((5.8599221412826100000E-4) * xz +\
1.3166052564989571850E-1) * xz + 1.1999463724910714109E+1)\
* xz + 4.6850901201934832188E+2) * xz +\
5.9169059852270512312E+3) * xz + 2.4708152720399552679E+3
sumq = ((1.0) * xz - 2.4994418972832303646E+2) * xz +\
2.1312714303849120380E+4
sumf = (((-1.6414452837299064100) * xz - 2.9601657892958843866E+2)\
* xz - 1.7733784684952985886E+4) * xz -\
4.0320340761145482298E+5
sumg = ((1.0 * xz - 2.5064972445877992730E+2) * xz +\
2.9865713163054025489E+4) * xz - 1.6128136304458193998E+6
retvalu = sump / sumq - math.log(xx) * (xz * sumf / sumg + 1.0)
elif (xx < DBLMAXLN):
xz = 1.0 / xx
sump = (((((((((1.1394980557384778174E+2) * xz +\
3.6832589957340267940E+3) * xz + 3.1075408980684392399E+4)\
* xz + 1.0577068948034021957E+5) * xz +\
1.7398867902565686251E+5) * xz + 1.5097646353289914539E+5)\
* xz + 7.1557062783764037541E+4) * xz +\
1.8321525870183537725E+4) * xz + 2.3444738764199315021E+3)\
* xz + 1.1600249425076035558E+2
sumq = ((((((((((1.0) * xz + 2.0013443064949242491E+2) * xz +\
4.4329628889746408858E+3) * xz + 3.1474655750295278825E+4)\
* xz + 9.7418829762268075784E+4) * xz +\
1.5144644673520157801E+5) * xz + 1.2689839587977598727E+5)\
* xz + 5.8824616785857027752E+4) * xz +\
1.4847228371802360957E+4) * xz + 1.8821890840982713696E+3)\
* xz + 9.2556599177304839811E+1
retvalu = sump / sumq / math.sqrt(xx) * math.exp(-xx)
else:
retvalu = 0.0
return (retvalu)
def bessK1(arg):
xx = arg
if (xx < DBLEPS):
retvalu = DBLMAX
elif (xx < DBLEPS):
retvalu = 1.0 / xx
elif (xx <= 1.0):
xz = xx * xx
sump = (((((4.8127070456878442310E-1) * xz +\
9.9991373567429309922E+1) * xz + 7.1885382604084798576E+3)\
* xz + 1.7733324035147015630E+5) * xz +\
7.1938920065420586101E+5) * xz - 2.2149374878243304548E+6
sumq = (((1.0) * xz - 2.8143915754538725829E+2) * xz +\
3.7264298672067697862E+4) * xz - 2.2149374878243304548E+6
sumf = ((((-2.2795590826955002390E-1) * xz -\
5.3103913335180275253E+1) * xz - 4.5051623763436087023E+3)\
* xz - 1.4758069205414222471E+5) * xz -\
1.3531161492785421328E+6
sumg = (((1.0) * xz - 3.0507151578787595807E+2) * xz +\
4.3117653211351080007E+4) * xz - 2.7062322985570842656E+6
retvalu = (xz * math.log(xx) * sumf / sumg + sump / sumq) / xx
elif (xx < DBLMAXLN):
xz = 1.0 / xx
sump = ((((((((((6.4257745859173138767E-2) * xz +\
7.5584584631176030810) * xz + 1.3182609918569941308E+2) *\
xz + 8.1094256146537402173E+2) * xz +\
2.3123742209168871550E+3) * xz + 3.4540675585544584407E+3)\
* xz + 2.8590657697910288226E+3) * xz +\
1.3319486433183221990E+3) * xz + 3.4122953486801312910E+2)\
* xz + 4.4137176114230414036E+1) * xz + 2.2196792496874548962
sumq = (((((((((1.0) * xz + 3.6001069306861518855E+1) * xz +\
3.3031020088765390854E+2) * xz + 1.2082692316002348638E+3)\
* xz + 2.1181000487171943810E+3) * xz +\
1.9448440788918006154E+3) * xz + 9.6929165726802648634E+2)\
* xz + 2.5951223655579051357E+2) * xz +\
3.4552228452758912848E+1) * xz + 1.7710478032601086579
retvalu = sump / sumq / math.sqrt(xx)
retvalu = retvalu * math.exp(-xx)
else:
retvalu = 0.0
return (retvalu)
def bessJn_ps(nn, xx):
if (nn < 0):
ann = -nn
else:
ann = nn
term = math.pow(xx / 2.0, ann) / factorial(ann)
xxsqr_div_four = -(xx * xx / 4.0)
sum = term
ff = 1
while True:
term *= xxsqr_div_four / (ff * (ann + ff))
sum_prev = sum
sum += term
if (iseq(sum, sum_prev)):
break# loop AWAIT
ff += 1
if (nn < 0 and isodd(nn)):
sum = -sum
return (sum)
def bessIn_ps(nn, xx):
if (nn < 0):
ann = -nn
else:
ann = nn
term = math.pow(xx / 2.0, ann) / factorial(ann)
xxsqr_div_four = xx * xx / 4.0
sum = term
ff = 1
while True:
term *= xxsqr_div_four / (ff * (ann + ff))
sum_prev = sum
sum += term
if (iseq(sum, sum_prev)):
break# loop AWAIT
ff += 1
return (sum)
def lf_besucjy0_xge5(xx, jfunc):
ww = 5.0 / xx
zz = 25.0 / (xx * xx)
numer = (((((((7.96936729297347051624E-4) * zz +\
8.28352392107440799803E-2) * zz + 1.23953371646414299388) *\
zz + 5.44725003058768775090) * zz + 8.74716500199817011941) *\
zz + 5.30324038235394892183) * zz + 9.99999999999999997821E-1)
denom = (((((((9.24408810558863637013E-4) * zz +\
8.56288474354474431428E-2) * zz + 1.25352743901058953537) *\
zz + 5.47097740330417105182) * zz + 8.76190883237069594232) *\
zz + 5.30605288235394617618) * zz + 1.00000000000000000218)
pp = numer / denom
numer = ((((((((-1.13663838898469149931E-2) * zz -\
1.28252718670509318512) * zz - 1.95539544257735972385E+1) *\
zz - 9.32060152123768231369E+1) * zz -\
1.77681167980488050595E+2) * zz - 1.47077505154951170175E+2)\
* zz - 5.14105326766599330220E+1) * zz - 6.05014350600728481186)
denom = ((((((((1.0) * zz + 6.43178256118178023184E+1) * zz +\
8.56430025976980587198E+2) * zz + 3.88240183605401609683E+3)\
* zz + 7.24046774195652478189E+3) * zz +\
5.93072701187316984827E+3) * zz + 2.06209331660327847417E+3)\
* zz + 2.42005740240291393179E+2)
qq = numer / denom
xn = xx - PI / 4.0
if (jfunc < 1):
pp = pp * math.cos(xn) - ww * qq * math.sin(xn)
else:
pp = pp * math.sin(xn) + ww * qq * math.cos(xn)
return (pp * TWOSQRT / math.sqrt(PI * xx))
def lf_besucjy1_xge5(xx, jfunc):
ww = 5.0 / xx
zz = 25.0 / (xx * xx)
numer = (((((((7.62125616208173112003E-4) * zz +\
7.31397056940917570436E-2) * zz + 1.12719608129684925192) *\
zz + 5.11207951146807644818) * zz + 8.42404590141772420927) *\
zz + 5.21451598682361504063) * zz + 1.00000000000000000254)
denom = (((((((5.71323128072548699714E-4) * zz +\
6.88455908754495404082E-2) * zz + 1.10514232634061696926) *\
zz + 5.07386386128601488557) * zz + 8.39985554327604159757) *\
zz + 5.20982848682361821619) * zz + 9.99999999999999997461E-1)
pp = numer / denom
numer = ((((((((5.10862594750176621635E-2) * zz +\
4.98213872951233449420) * zz + 7.58238284132545283818E+1) *\
zz + 3.66779609360150777800E+2) * zz +\
7.10856304998926107277E+2) * zz + 5.97489612400613639965E+2)\
* zz + 2.11688757100572135698E+2) * zz +\
2.52070205858023719784E+1)
denom = ((((((((1.0) * zz + 7.42373277035675149943E+1) * zz +\
1.05644886038262816351E+3) * zz + 4.98641058337653607651E+3)\
* zz + 9.56231892404756170795E+3) * zz +\
7.99704160447350683650E+3) * zz + 2.82619278517639096600E+3)\
* zz + 3.36093607810698293419E+2)
qq = numer / denom
xn = xx - 3.0 * PI / 4.0
if (jfunc < 1):
pp = pp * math.cos(xn) - ww * qq * math.sin(xn)
else:
pp = pp * math.sin(xn) + ww * qq * math.cos(xn)
return (pp * TWOSQRT / math.sqrt(PI * xx))
def bessJ0(xx):
if (xx < 0.0):
xx = -xx
zz = xx * xx
if (xx < 1.0E-5):
retvalu = 1.0 - zz / 4.0
elif (xx < 5.0):
numer = ((((-4.79443220978201773821E+9) * zz +\
1.95617491946556577543E+12) * zz -\
2.49248344360967716204E+14) * zz + 9.70862251047306323952E+15)
denom = (((((((((1.0) * zz + 4.99563147152651017219E+2) * zz +\
1.73785401676374683123E+5) * zz +\
4.84409658339962045305E+7) * zz +\
1.11855537045356834862E+10) * zz +\
2.11277520115489217587E+12) * zz +\
3.10518229857422583814E+14) * zz +\
3.18121955943204943306E+16) * zz + 1.71086294081043136091E+18)
retvalu = (zz - 5.783185962946784521175) * (zz -\
30.4712623436620863991) * numer / denom
else:
retvalu = lf_besucjy0_xge5(xx, 0)
return (retvalu)
def bessJ1(xx):
ww = xx
if (ww < 0.0):
ww = -ww
if (ww < 5.0):
zz = ww * ww
numer = ((((-8.99971225705559398224E+8) * zz +\
4.52228297998194034323E+11) * zz -\
7.27494245221818276015E+13) * zz + 3.68295732863852883286E+15)
denom = (((((((((1.0) * zz + 6.20836478118054335476E+2) * zz +\
2.56987256757748830383E+5) * zz +\
8.35146791431949253037E+7) * zz +\
2.21511595479792499675E+10) * zz +\
4.74914122079991414898E+12) * zz +\
7.84369607876235854894E+14) * zz +\
8.95222336184627338078E+16) * zz + 5.32278620332680085395E+18)
retvalu = numer / denom * xx * (zz - 14.6819706421238932572) * (zz\
- 49.2184563216946036703)
else:
retvalu = lf_besucjy1_xge5(xx, 0)
return (retvalu)
def bessY0(xx):
if (xx <= 0.0):
retvalu = DBLMAX
else:
zz = xx * xx
if (xx < 1.0E-5):
retvalu = 1.0 - zz / 4.0
elif (xx < 5.0):
numer = ((((((((1.55924367855235737965E+4) * zz -\
1.46639295903971606143E+7) * zz +\
5.43526477051876500413E+9) * zz -\
9.82136065717911466409E+11) * zz +\
8.75906394395366999549E+13) * zz -\
3.46628303384729719441E+15) * zz +\
4.42733268572569800351E+16) * zz -\
1.84950800436986690637E+16)
denom = ((((((((1.0) * zz + 1.04128353664259848412E+3) * zz +\
6.26107330137134956842E+5) * zz +\
2.68919633393814121987E+8) * zz +\
8.64002487103935000337E+10) * zz +\
2.02979612750105546709E+13) * zz +\
3.17157752842975028269E+15) * zz +\
2.50596256172653059228E+17)
retvalu = numer / denom + 2.0 * math.log(xx) * bessJ0(xx) / PI
else:
retvalu = lf_besucjy0_xge5(xx, 1)
return (retvalu)
def bessY1(xx):
ww = xx
if (xx <= 0.0):
retvalu = -DBLMAX
elif (ww <= 5.0):
zz = ww * ww
numer = ((((((1.2632047479017802640E+9) * zz -\
6.47355876379160291031E+11) * zz +\
1.14509511541823727583E+14) * zz -\
8.12770255501325109621E+15) * zz +\
2.02439475713594898196E+17) * zz - 7.78877196265950026825E+17)
denom = (((((((((1.0) * zz + 5.94301592346128195359E+2) * zz +\
2.35564092943068577943E+5) * zz +\
7.34811944459721705660E+7) * zz +\
1.87601316108706159478E+10) * zz +\
3.88231277496238566008E+12) * zz +\
6.20557727146953693363E+14) * zz +\
6.87141087355300489866E+16) * zz + 3.97270608116560655612E+18)
retvalu = xx * numer / denom + 2.0 * (bessJ1(xx) * math.log(xx) -\
1.0 / xx) / PI
else:
retvalu = lf_besucjy1_xge5(xx, 1)
return (retvalu)
def lf_bess_ucrecur(nn, xx, fzero, fone):
if (nn <= 0):
cv = fzero
elif (nn == 1):
cv = fone
else:
tox = 2.0 / xx
av = fzero
bv = fone
for ii in range(1, nn + 0, 1):
cv = tox * ii * bv - av
av = bv
bv = cv
return (cv)
def lf_limi(nn):
return int((nn + floor(math.sqrt(40.0 * nn))))
def lf_bess_ucrecur2(nn, xx):
flipflop = 0
sjm = 0.0
tox = 2.0 / math.fabs(xx)
retvalu = 0.0
bzp = 0.0
bzc = 1.0
limi = lf_limi(nn)
if (isodd(limi)):
limi -= 1
for jj in range(limi, 0, -1):
bzm = jj * tox * bzc - bzp
bzp = bzc
bzc = bzm
if (flipflop == 0):
flipflop = 1
else:
sjm += bzc
flipflop = 0
if (jj == nn):
retvalu = bzp
sjm = 2.0 * sjm - bzc
retvalu /= sjm
return (retvalu)
def bessIn(nn, xx):
if (nn < 0 or iszero(xx)):
retvalu = 0.0
elif (nn == 0):
axx = math.fabs(xx)
retvalu = bessI0(axx)
elif (nn == 1):
axx = math.fabs(xx)
retvalu = bessI1(axx)
else:
tox = 2.0 / math.fabs(xx)
retvalu = 0.0
bzp = 0.0
bzc = 1.0
limi = 2 * lf_limi(nn)
for jj in range(limi, 0, -1):
bzm = bzp + jj * tox * bzc
bzp = bzc
bzc = bzm
if (jj == nn):
retvalu = bzp
retvalu *= bessI0(xx) / bzc
if (xx < 0.0 and isodd(nn)):
retvalu = -retvalu
return (retvalu)
def bessJn(nn, xx):
if (nn == 0):
retvalu = bessJ0(xx)
elif (nn == 1):
retvalu = bessJ1(xx)
elif (nn < math.fabs(xx)):
retvalu = lf_bess_ucrecur(nn, xx, bessJ0(xx), bessJ1(xx))
else:
retvalu = lf_bess_ucrecur2(nn, xx)
return (retvalu)
def bessYn(nn, xx):
if (nn == 0):
retvalu = bessY0(xx)
elif (nn == 1):
retvalu = bessY1(xx)
else:
retvalu = lf_bess_ucrecur(nn, xx, bessY0(xx), bessY1(xx))
return (retvalu)
def bessKn(nn, xx):
if (nn < 0 or iszero(xx)):
retvalu = 0.0
elif (nn == 0):
retvalu = bessK0(xx)
elif (nn == 1):
retvalu = bessK1(xx)
else:
retvalu = lf_bess_ucrecur(nn, xx, bessK0(xx), bessK1(xx))
return (retvalu)
def bessYn_ps(nn, xx):
if (nn < 0 or iszero(xx)):
retvalu = 0.0
elif (nn == 0):
xxsqr_div_four = xx * xx / 4.0
sum = (math.log(xx / 2.0) + EULER) * bessJn(0, xx)
term = -1
hn = 0.0
kk = 1
while True:
hn += 1.0 / kk
term *= - xxsqr_div_four / (kk * kk)
sum_prev = sum
sum += term * hn
if (iseq(sum, sum_prev)):
break# loop AWAIT
kk += 1
retvalu = 2.0 * sum / PI
elif (nn == 1):
retvalu = bessY1(xx)
else:
retvalu = lf_bess_ucrecur(nn, xx, bessY0(xx), bessY1(xx))
return (retvalu)
def bessY1__1(xx):
if (iszero(xx)):
retvalu = -DBLMAX
elif (xx < 8.0):
yy = xx * xx
numer = ((((((8.511937935E+3) * yy - 4.237922726E+6) * yy +\
7.349264551E+8) * yy - 5.153438139E+10) * yy +\
1.275274390E+12) * yy - 4.900604943E+12)
denom = (((((((1.0) * yy + 3.549632885E+2) * yy + 1.020426050E+5) *\
yy + 2.245904002E+7) * yy + 3.733650367E+9) * yy +\
4.244419664E+11) * yy + 2.499580570E+13)
retvalu = 2.0 * (bessJn(1, xx) * math.log(xx) - 1.0 / xx) / PI + xx\
* (numer / denom)
else:
zz = 8.0 / xx
yy = zz * zz
numer = (((((-2.403370190E-7) * yy + 2.457520174E-6) * yy -\
3.516396496E-5) * yy + 1.831050000E-3) * yy + 1.0)
denom = (((((1.057874120E-7) * yy - 8.822898700E-7) * yy +\
8.449199096E-6) * yy - 2.002690873E-4) * yy + 4.687499995E-2)
ww = xx - 0.75 * PI
retvalu = TWOSQRT / math.sqrt(PI * xx) * (math.sin(ww) * numer + zz\
* math.cos(ww) * denom)
return (retvalu)
def lf_bess_lcrecur(nn, xx, fzero, fone):
if (nn <= 0):
cv = fzero
elif (nn == 1):
cv = fone
else:
av = fzero
bv = fone
for ii in range(1, nn + 0, 1):
cv = (2.0 * ii + 1.0) * bv / xx - av
av = bv
bv = cv
return (cv)
def bess_jn(nn, xx):
if (iszero(xx)):
if (nn == 0):
retvalu = 1.0
else:
retvalu = 0.0
else:
jk_a = math.sin(xx) / xx
jk_b = (math.sin(xx) - xx * math.cos(xx)) / (xx * xx)
if (nn <= 0):
retvalu = jk_a
elif (nn <= 1):
retvalu = jk_b
else:
retvalu = lf_bess_lcrecur(nn, xx, jk_a, jk_b)
return (retvalu)
def bess_yn(nn, xx):
if (iszero(xx)):
if (nn == 0):
retvalu = 1.0
else:
retvalu = 0.0
else:
yk_a = -math.cos(xx) / xx
yk_b = (-math.cos(xx) - xx * math.sin(xx)) / (xx * xx)
if (nn <= 0):
retvalu = yk_a
elif (nn <= 1):
retvalu = yk_b
else:
retvalu = lf_bess_lcrecur(nn, xx, yk_a, yk_b)
return (retvalu)
lv_partitionr_arr = [0 for ii in range(0)]
lv_partitionr_end = 0
def partition(nn):
global lv_partitionr_arr
global lv_partitionr_end
if (nn < 0):
retvalu = 0.0
else:
if (lv_partitionr_end <= 0):
lv_partitionr_end = 6
for nzzn in range(len(lv_partitionr_arr), int(lv_partitionr_end)):
lv_partitionr_arr.append(0)
lv_partitionr_arr[0] = 1.0
lv_partitionr_arr[1] = 1.0
lv_partitionr_arr[2] = 2.0
lv_partitionr_arr[3] = 3.0
lv_partitionr_arr[4] = 5.0
lv_partitionr_arr[5] = 7.0
if (lv_partitionr_end <= nn):
ii = lv_partitionr_end
lv_partitionr_end = nn + 1
for nzzn in range(len(lv_partitionr_arr), int(lv_partitionr_end)):
lv_partitionr_arr.append(0)
while (ii < lv_partitionr_end):
sum = 0.0
ssign = 1.0
kk = 1
jj = ii - 1
while (0 <= jj):
sum += ssign * lv_partitionr_arr[jj]
jj -= kk
if (jj < 0):
break
sum += ssign * lv_partitionr_arr[jj]
ssign = -ssign
kk += 1
jj -= (2 * kk - 1)
lv_partitionr_arr[ii] = sum
ii += 1
retvalu = lv_partitionr_arr[nn]
return (retvalu)
lv_partitionq_arr = [0 for ii in range(0)]
lv_partitionq_end = 0
def partitionq(nn):
global lv_partitionq_arr
global lv_partitionq_end
if (nn < 0):
retvalu = 0.0
else:
if (lv_partitionq_end <= 0):
lv_partitionq_end = 6
for nzzn in range(len(lv_partitionq_arr), int(lv_partitionq_end)):
lv_partitionq_arr.append(0)
lv_partitionq_arr[0] = 1.0
lv_partitionq_arr[1] = 1.0
lv_partitionq_arr[2] = 1.0
lv_partitionq_arr[3] = 2.0
lv_partitionq_arr[4] = 2.0
lv_partitionq_arr[5] = 3.0
if (lv_partitionq_end <= nn):
ii = lv_partitionq_end
lv_partitionq_end = nn + 1
for nzzn in range(len(lv_partitionq_arr), int(lv_partitionq_end)):
lv_partitionq_arr.append(0)
while (ii < lv_partitionq_end):
sum = 0.0
ssign = 1.0
kk = 1
jj = ii - 1
while (0 <= jj):
sum += ssign * lv_partitionq_arr[jj]
jj -= kk
if (jj < 0):
break
sum += ssign * lv_partitionq_arr[jj]
ssign = -ssign
kk += 1
jj -= (2 * kk - 1)
ee = round(math.sqrt(1.0 + 12.0 * ii) / 6.0)
if (ii == (3 * ee * ee - ee) or ii == (3 * ee * ee + ee)):
if (isodd(ee)):
sum -= 1.0
else:
sum += 1.0
lv_partitionq_arr[ii] = sum
ii += 1
retvalu = lv_partitionq_arr[nn]
return (retvalu)
def bitwisenot(xx):
retvalu = ~xx
return int(retvalu)
def bitwiseand(xx, yy):
retvalu = (xx & yy)
return int(retvalu)
def bitwiseor(xx, yy):
retvalu = (xx | yy)
return int(retvalu)
def bitwisexor(xx, yy):
retvalu = (xx ^ yy)
return int(retvalu)
def bitshiftl(hexnumber, shift_count):
if (shift_count < 0):
retvalu = (hexnumber >> (- shift_count))
elif (0 < shift_count):
retvalu = (hexnumber << shift_count)
else:
retvalu = hexnumber
return int(retvalu)
def bitshiftr(hexnumber, shift_count):
if (shift_count < 0):
retvalu = (hexnumber << (- shift_count))
elif (0 < shift_count):
retvalu = (hexnumber >> shift_count)
else:
retvalu = hexnumber
return int(retvalu)
def bits_count(hexnumber):
bitmask = 1
bit_counter = 0
while (bitmask <= hexnumber):
if (bitwiseand(bitmask, hexnumber) != 0):
bit_counter += 1
bitmask = (bitmask << 1)
return int(bit_counter)
def bits_ls1b(orig):
if (orig == 0):
retvalu = 0
else:
divisor = 1
while (0 == (divisor & orig)):
divisor *= 2
retvalu = divisor
return int(retvalu)
def bits_ms1b(orig):
if (orig == 0):
retvalu = 0
else:
divisor = -2
while ((divisor & orig) != 0):
divisor *= 2
retvalu = -divisor / 2
return int(retvalu)
def bits_ls1bpos(orig):
if (orig == 0):
retvalu = -1
else:
divisor = 1
bit_count = 0
while (0 == (divisor & orig)):
divisor *= 2
bit_count += 1
retvalu = bit_count
return int(retvalu)
def bits_ms1bpos(orig):
if (orig == 0):
retvalu = 0
else:
divisor = -2
bit_count = 0
while ((divisor & orig) != 0):
divisor *= 2
bit_count += 1
retvalu = bit_count
return int(retvalu)
def bits_assign(orig, value_to_set, which_mask):
if (which_mask == 0):
retvalu = orig
else:
divisor = bits_ls1bpos(which_mask)
tempo = (orig & (~which_mask))
tempv = (value_to_set << divisor)
retvalu = (tempo | (tempv & which_mask))
return int(retvalu)
def bits_get(vall, mask):
return int(((vall & mask) / bits_ls1b(mask)))
def bits_set(vall, mask):
return int((((vall * bits_ls1b(mask)) & mask)))
def lf_calerf(xx, jint):
absx = math.fabs(xx)
xsq = xx * xx
flag = 0
if (absx <= 0.46875):
numer = (((((1.85777706184603153E-1) * xsq + 3.16112374387056560) *\
xsq + 1.13864154151050156E+2) * xsq +\
3.77485237685302021E+2) * xsq + 3.20937758913846947E+3)
denom = (((((1.00000000000000000) * xsq + 2.36012909523441209E+1) *\
xsq + 2.44024637934444173E+2) * xsq +\
1.28261652607737228E+3) * xsq + 2.84423683343917062E+3)
retvalu = xx * numer / denom
if (jint == 1):
retvalu = 1.0 - retvalu
elif (jint == 2):
retvalu = math.exp(xsq) * (1.0 - retvalu)
flag = 1
elif (absx <= 4.0):
numer = (((((((((2.15311535474403846E-8) * absx +\
5.64188496988670089E-1) * absx + 8.88314979438837594) *\
absx + 6.61191906371416295E+1) * absx +\
2.98635138197400131E+2) * absx + 8.81952221241769090E+2) *\
absx + 1.71204761263407058E+3) * absx +\
2.05107837782607147E+3) * absx + 1.23033935479799725E+3)
denom = (((((((((1.00000000000000000) * absx +\
1.57449261107098347E+1) * absx + 1.17693950891312499E+2) *\
absx + 5.37181101862009858E+2) * absx +\
1.62138957456669019E+3) * absx + 3.29079923573345963E+3) *\
absx + 4.36261909014324716E+3) * absx +\
3.43936767414372164E+3) * absx + 1.23033935480374942E+3)
result = numer / denom
else:
rsqrpi = math.sqrt(1.0 / PI)
if (jint != 2 and math.sqrt(math.log(DBLMAX)) <= absx):
result = 0.0
elif (jint == 2 and 6.71E+7 <= absx):
if (DBLMAX / 8.0 <= absx):
result = 0.0
else:
result = rsqrpi / absx
else:
rxsq = 1.0 / (absx * absx)
numer = ((((((-1.63153871373020978E+2) * rxsq -\
3.05326634961232344E+3) * rxsq -\
3.60344899949804439E+3) * rxsq -\
1.25781726111229246E+3) * rxsq -\
1.60837851487422766E+2) * rxsq - 6.58749161529837803)
denom = ((((((1.00000000000000000E+4) * rxsq +\
2.56852019228982242E+4) * rxsq +\
1.87295284992346047E+4) * rxsq +\
5.27905102951428412E+3) * rxsq +\
6.05183413124413191E+2) * rxsq + 2.33520497626869185E+1)
result = (rsqrpi + rxsq * numer / denom) / absx
if (flag == 0):
if (jint == 2):
if (xx < - math.sqrt(math.log(DBLMAX))):
retvalu = DBLMAX
elif (xx < 0.0):
retvalu = 2.0 * math.exp(xsq) - result
else:
retvalu = result
else:
result *= math.exp(-xsq)
if (jint == 0):
if (0.0 <= xx):
retvalu = (0.5 - result) + 0.5
else:
retvalu = -((0.5 - result) + 0.5)
elif (jint == 1):
if (xx < 0.0):
retvalu = 2.0 - result
else:
retvalu = result
else:
retvalu = 0.0
return (retvalu)
def erf(xx):
return (lf_calerf(xx, 0))
def erfc(xx):
return (lf_calerf(xx, 1))
def erfcx(xx):
return (lf_calerf(xx, 2))
def erfcinv(yy_orig):
if (yy_orig <= 0.0):
retvalu = DBLMAX / 2.0
elif (2.0 <= yy_orig):
retvalu = -(DBLMAX / 2.0)
elif (iszero(yy_orig - 1.0)):
retvalu = 0.0
else:
if (1.0 < yy_orig):
yy = 2.0 - yy_orig
else:
yy = yy_orig
dx = 1.0
xx = 0.0
cc = -math.sqrt(TAU / 8.0)
ii = 0
while True:
uu = cc * (erfcx(xx) - yy * math.exp(xx * xx))
dx = -uu / (1.0 + uu * xx)
xx_pr = xx
xx += dx
if (iseq(xx_pr, xx)):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
if (1.0 < yy_orig):
retvalu = -xx
else:
retvalu = xx
return (retvalu)
def erfcxinv(yy):
xx = 0.0
if (not iszero(yy - 1.0)):
dx = 1.0
cc = math.sqrt(8.0 / TAU)
ii = 0
while True:
ex = erfcx(xx)
df = 2.0 * xx * ex - cc
uu = (ex - yy) / df
dx = -uu / (1.0 - uu * (xx + ex / df))
xx_pr = xx
xx += dx
if (iseq(xx_pr, xx)):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
return (xx)
def erfinv(yy):
if (iszero(yy)):
retvalu = 0.0
elif (0.5 < yy):
retvalu = erfcinv(1.0 - yy)
elif (yy < - 0.5):
retvalu = -erfcinv(1.0 + yy)
else:
dx = 1.0
xx = 0.0
cc = math.sqrt(TAU / 8.0)
ii = 0
while True:
uu = cc * (erf(xx) - yy) * math.exp(xx * xx)
dx = -uu / (1.0 + uu * xx)
xx_pr = xx
xx += dx
if (iseq(xx_pr, xx)):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xx
return (retvalu)
def erf__1(xx):
tt = (1.0 / (1.0 + (0.5 * math.fabs(xx))))
ply = ((((((((((1.70872770E-1) * tt - 8.22152230E-1) * tt +\
1.48851587) * tt - 1.13520398) * tt + 2.78868070E-1) * tt -\
1.86288060E-1) * tt + 9.67841800E-2) * tt + 3.74091960E-1) *\
tt + 1.00002368) * tt - 1.26551223)
ans = 1.0 - tt * math.exp((-xx * xx) + ply)
if (xx < 0.0):
ans = -ans
return (ans)
def erf__2(xx):
tt = 1.0 / (1.0 + 0.3275911 * math.fabs(xx))
ply = ((((((1.061405429) * tt - 1.453152027) * tt + 1.421413741) * tt\
- 2.844967360E-1) * tt + 2.548295920E-1) * tt + 0.000000000)
ans = 1.0 - math.exp(-xx * xx) * ply
if (xx < 0.0):
ans = -ans
return (ans)
def erf__3(xx):
add_arr = [0 for ii in range(80)]
axx = math.fabs(xx)
xxsq = xx * xx
if (axx < 4.4):
factx = 1.0
add_arr[0] = 1
nn = 1
while True:
factx *= - xxsq / nn
add_arr[nn] = factx / (2.0 * nn + 1.0)
if (math.fabs(add_arr[nn]) < DBLEPS):
break# loop AWAIT
nn += 1
if (79 <= nn):
break# loop AWAIT
sum_curr = 0.0
for kk in range(nn, -1, -1):
sum_curr += add_arr[kk]
sum_curr *= (2.0 * xx / math.sqrt(PI))
else:
factx = -math.exp(-xxsq) / math.sqrt(PI)
sum_curr = 0.0
kk = round(xxsq)
for nn in range(1, kk + 0, 1):
factx *= - (2.0 * nn - 1.0) / (2.0 * xxsq)
sum_curr += factx
sum_curr += 1.0 - math.exp(-xxsq) / math.sqrt(PI) / axx
if (xx < 0.0):
sum_curr = -sum_curr
return (sum_curr)
def erf__4(xx):
axx = math.fabs(xx)
xxsq = xx * xx
twoxxsq = 2.0 * xxsq
sum_curr = 0.0
if (axx < 4.4):
factz = (2.0 * xx / math.sqrt(PI))
factx = factz
nn = 3
while True:
twonnpone = 2 * nn + 1
factx *= xxsq * xxsq / ((nn - 1.0) * nn)
denom = 4.0 * nn * nn - 1.0
term = factx * (twonnpone * (nn - xxsq) + twoxxsq) / denom
sum_prev = sum_curr
sum_curr += term
if (iseq(sum_prev, sum_curr)):
break# loop AWAIT
nn += 2
sum_curr += (1.0 - xxsq / 3.0) * factz
else:
factx = -math.exp(-xxsq) / (xx * math.sqrt(PI))
kk = round(xxsq)
for nn in range(1, kk - 3, 2):
factx *= nn * (nn + 1.0) / (twoxxsq * twoxxsq)
term = factx * (1.0 - (2.0 * nn + 1.0) / twoxxsq)
sum_prev = sum_curr
sum_curr += term
if (iseq(sum_prev, sum_curr)):
break
sum_curr += 1.0 - math.exp(-xxsq) / math.sqrt(PI) / axx
if (xx < 0.0):
sum_curr = -sum_curr
return (sum_curr)
def lgamma__1(xx):
aa_arr = [0 for ii in range(15)]
if (xx <= 0.0 and isint(xx)):
retvalu = math.log(DBLMAX)
else:
if (xx < 0.0):
qq = 1.0 - xx
else:
qq = xx
aa_arr[0] = +5.7156235665862923517E+1
aa_arr[1] = -5.9597960355475491248E+1
aa_arr[2] = +1.4136097974741747174E+1
aa_arr[3] = -4.9191381609762019978E-1
aa_arr[4] = +3.3994649984811888699E-5
aa_arr[5] = +4.6523628927048575665E-5
aa_arr[6] = -9.8374475304879564677E-5
aa_arr[7] = +1.5808870322491248884E-4
aa_arr[8] = -2.1026444172410488319E-4
aa_arr[9] = +2.1743961811521264320E-4
aa_arr[10] = -1.6431810653676389022E-4
aa_arr[11] = +8.4418223983852743293E-5
aa_arr[12] = -2.6190838401581408670E-5
aa_arr[13] = +3.6899182659531622704E-6
sum = 0.99999999999999709182
for ii in range(0, 14, 1):
sum += aa_arr[ii] / (qq + ii)
tt = qq + 607.0 / 128.0 - 0.5
qq = math.log(TAU) / 2.0 + (qq - 0.5) * math.log(tt) +\
math.log(sum) - tt
if (xx < 0.0):
retvalu = math.log(PI / math.fabs(math.sin(2.0 * TAU * xx))) - qq
else:
retvalu = qq
return (retvalu)
def lgammainv(yy):
yy_fixed = yy / PI + math.log(yy + 0.5)
xx_init = yy_fixed + PI - 0.5
scvx_dx = 0.01
scvx_xx = xx_init
scvx_yy = yy - lgamma(scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = yy - lgamma(scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def lf_lgamma_gt_zero(xx):
if (xx < 13.0):
zz = 1.0
pp = 0.0
uu = xx
while (3.0 <= uu):
pp -= 1.0
uu = xx + pp
zz *= uu
while (uu < 2.0):
zz /= uu
pp += 1.0
uu = xx + pp
if (zz < 0.0):
zz = -zz
if (iseq(uu, 2.0)):
retvalu = math.log(zz)
else:
pp -= 2.0
xx += pp
numer = ((((((-1.37825152569120859100E+3) * xx -\
3.88016315134637840924E+4) * xx -\
3.31612992738871184744E+5) * xx -\
1.16237097492762307383E+6) * xx -\
1.72173700820839662146E+6) * xx -\
8.53555664245765465627E+5)
denom = (((((((1.0) * xx - 3.51815701436523470549E+2) * xx -\
1.70642106651881159223E+4) * xx -\
2.20528590553854454839E+5) * xx -\
1.13933444367982507207E+6) * xx -\
2.53252307177582951285E+6) * xx -\
2.01889141433532773231E+6)
retvalu = math.log(zz) + xx * numer / denom
else:
uu = (xx - 0.5) * math.log(xx) - xx + math.log(math.sqrt(TAU))
if (1.0E+8 < xx):
retvalu = uu
else:
pp = 1.0 / (xx * xx)
if (1000.0 < xx):
zz = (((7.9365079365079365079365E-4) * pp -\
2.7777777777777777777778E-3) * pp +\
8.3333333333333333333333E-2)
else:
zz = (((((8.11614167470508450300E-4) * pp -\
5.95061904284301438324E-4) * pp +\
7.93650340457716943945E-4) * pp -\
2.77777777300996872050E-3) * pp +\
8.33333333333331927722E-2)
retvalu = uu + zz / xx
return (retvalu)
def lgamma(zz):
if (zz <= 0.0):
if (isint(zz)):
retvalu = math.log(DBLMAX)
else:
retvalu = (math.log(PI / math.fabs(math.sin(2.0 * TAU * zz))) -\
lf_lgamma_gt_zero(1.0 - zz))
else:
retvalu = lf_lgamma_gt_zero(zz)
return (retvalu)
def lf_eval_cont(xx, deg, coeff_arr_pc):
sum = xx
for ii in range(deg, -1, -1):
sum = xx + coeff_arr_pc[ii] / sum
return (sum)
def lgamma__2(zz):
aa_arr = [0 for ii in range(10)]
if (zz <= 0.0):
if (isint(zz)):
retvalu = math.log(DBLMAX)
else:
retvalu = (math.log(PI / math.fabs(math.sin(2.0 * TAU * zz))) -\
lgamma(1.0 - zz))
else:
aa_arr[0] = +1.0 / 12.0
aa_arr[1] = +1.0 / 30.0
aa_arr[2] = +53.0 / 210.0
aa_arr[3] = +195.0 / 371.0
aa_arr[4] = +229999.0 / 22737.0
aa_arr[5] = +29944523.0 / 19733142.0
aa_arr[6] = +109535241009.0 / 48264275462.0
aa_arr[7] = +29404527905795295658.0 / 9769214287853155785.0
aa_arr[8] = +455377030420113432210116914702.0 /\
113084128923675014537885725485.0
sum = 0.0
while (zz <= 6.0):
sum += math.log(zz)
zz += 1.0
sum -= lf_eval_cont(zz, 8, aa_arr)
retvalu = (math.log(TAU) / 2.0 + (zz - 0.5) * math.log(zz) - 2.0 *\
zz - sum)
return (retvalu)
def lpermx(nn, rr):
return (lgamma(nn + 1.0) - lgamma(nn - rr + 1.0))
def permx(nn, rr):
return (math.exp(lpermx(nn, rr)))
def lcombx(nn, rr):
return (lpermx(nn, rr) - lgamma(rr + 1.0))
def combx(nn, rr):
return (math.exp(lcombx(nn, rr)))
def birthdayx(nn, rr):
return (math.exp(lpermx(nn, rr) - math.log(nn) * rr))
def tgamma__1(xx):
if (isposint(1.0 - xx)):
rslt = DBLMAX
else:
zz = 1.0
while (3.0 <= xx):
xx -= 1.0
zz *= xx
while (xx < 2.0):
if (math.fabs(xx) < 1.0E-9):
break
zz /= xx
xx += 1.0
if (iseq(xx, 0.0)):
rslt = DBLMAX
elif (xx < 2.0):
rslt = zz / ((1.0 + EULER * xx) * xx)
elif (iseq(xx, 2.0)):
rslt = zz
else:
xx -= 2.0
numer = (((((((1.60119522476751861407E-4) * xx +\
1.19135147006586384913E-3) * xx +\
1.04213797561761569935E-2) * xx +\
4.76367800457137231464E-2) * xx +\
2.07448227648435975150E-1) * xx +\
4.94214826801497100753E-1) * xx +\
9.99999999999999996796E-1)
denom = ((((((((-2.31581873324120129819E-5) * xx +\
5.39605580493303397842E-4) * xx -\
4.45641913851797240494E-3) * xx +\
1.18139785222060435552E-2) * xx +\
3.58236398605498653373E-2) * xx -\
2.34591795718243348568E-1) * xx +\
7.14304917030273074085E-2) * xx + 1.00000000000000000320)
rslt = zz * numer / denom
return (rslt)
def tgamma(xx):
if (xx < 0.0):
if (isint(xx)):
retvalu = DBLMAX
else:
tmp = math.exp(lgamma(1.0 - xx))
retvalu = PI / (math.sin(PI * xx) * tmp)
else:
retvalu = math.exp(lgamma(xx))
return (retvalu)
def tgammainv(yy):
kk = GAMMAMIN
cc = math.sqrt(TAU) / E - tgamma(kk)
pp = math.log((yy + cc) / math.sqrt(TAU))
xx_init = pp / wp(pp / E) + 0.5
scvx_dx = 0.01
scvx_xx = xx_init
scvx_yy = yy - tgamma(scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = yy - tgamma(scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def lf_gamma_shift(xx, yy):
if (isposint(1.0 - yy)):
prod = DBLMAX
else:
prod = 1.0
while (yy < xx - 0.0001):
prod *= yy
yy += 1.0
while (xx + 0.0001 < yy):
yy -= 1.0
prod /= yy
return (prod)
def lf_tgamma_gt_half(xx):
pp_arr = [0 for ii in range(11)]
yy = xx - floor(xx) + 1.0
pp_arr[0] = +5.716400188274341379136E+3
pp_arr[1] = -1.481530426768413909044E+4
pp_arr[2] = +1.429149277657478554025E+4
pp_arr[3] = -6.348160217641458813289E+3
pp_arr[4] = +1.301608286058321874105E+3
pp_arr[5] = -1.081767053514369634679E+2
pp_arr[6] = +2.605696505611755827729
pp_arr[7] = -7.423452510201416151527E-3
pp_arr[8] = +5.384136432509564062961E-8
pp_arr[9] = -4.023533141268236372067E-9
sum = 1.000000000000000174663
for ii in range(0, 10, 1):
sum += pp_arr[ii] / (yy + ii)
ex = math.log(yy + 8.5) * (yy - 0.5) - yy - 8.5
return (math.sqrt(TAU) * sum * lf_gamma_shift(xx, yy) * math.exp(ex))
def tgamma__2(xx):
pp_arr = [0 for ii in range(10)]
if (isposint(1.0 - xx)):
rslt = DBLMAX
else:
yy = xx - floor(xx) + 2.0
pp_arr[0] = +7.61800917294715E+1
pp_arr[1] = -8.65053203294168E+1
pp_arr[2] = +2.40140982408309E+1
pp_arr[3] = -1.23173957245015
pp_arr[4] = +1.20865097386618E-3
pp_arr[5] = -5.395239384953E-6
sum = 1.00000000019001
for ii in range(0, 6, 1):
sum += pp_arr[ii] / (yy + ii)
ex = math.log(yy + 4.5) * (yy - 0.5) - yy - 4.5
rslt = math.sqrt(TAU) * sum * lf_gamma_shift(xx, yy) * math.exp(ex)
return (rslt)
def tgamma__3(xx):
if (isposint(1.0 - xx)):
retvalu = DBLMAX
elif (xx < 0.5):
retvalu = PI / (math.sin(PI * xx) * lf_tgamma_gt_half(1.0 - xx))
else:
retvalu = lf_tgamma_gt_half(xx)
return (retvalu)
def tgamma__stirling(xx):
sc = 1.0
while (xx < 10.0):
sc /= xx
xx += 1.0
yy = xx - 1.0
ryy = 1.0 / yy
ply = (((((((-5246819.0 / 75246796800.0) * ryy + 163879.0 /\
209018880.0) * ryy - 571.0 / 2488320.0) * ryy - 139.0 /\
51840) * ryy + 1.0 / 288.0) * ryy + 1.0 / 12.0) * ryy + 1.0)
return (sc * math.pow(yy / E, yy) * math.sqrt(TAU * yy) * ply)
def tgammadouble(xx):
xxh = (xx - 1.0) / 2.0
return (math.pow(2.0, xxh) * tgamma(xxh + 1.0) * math.pow(2.0 / PI,\
(1.0 - math.cos(TAU * xxh)) / 4.0))
def lf_ligamma_xxleaa(aa, xx):
sum_curr = math.exp(aa * math.log(xx) - xx) / aa
rr = sum_curr
for kk in range(1, 101, 1):
rr *= xx / (aa + kk)
sum_prev = sum_curr
sum_curr += rr
if (iseq(sum_prev, sum_curr)):
break
return (sum_curr)
def lf_uigamma_aalexx(aa, xx):
sum_curr = 0.0
pp = 47.0 / math.sqrt(xx - 0.75)
ipp = floor(pp)
for jj in range(ipp, 0, -1):
tt = xx + sum_curr
sum_curr = (jj - aa) * tt / (tt + jj)
return (math.exp(aa * math.log(xx) - xx) / (xx + sum_curr))
def ligamma(aa, xx):
if (xx <= 0.0):
retvalu = 0.0
elif (aa <= 0.0):
retvalu = DBLMAX
elif (xx <= 1.1 or xx <= aa):
retvalu = lf_ligamma_xxleaa(aa, xx)
else:
retvalu = tgamma(aa) - lf_uigamma_aalexx(aa, xx)
return (retvalu)
def uigamma(aa, xx):
if (aa <= 0.0):
retvalu = DBLMAX
elif (xx <= 0.0):
retvalu = tgamma(aa)
elif (xx <= 1.1 or xx <= aa):
retvalu = tgamma(aa) - lf_ligamma_xxleaa(aa, xx)
else:
retvalu = lf_uigamma_aalexx(aa, xx)
return (retvalu)
def rligamma(aa, xx):
if (xx <= 0.0):
retvalu = 0.0
elif (aa <= 0.0):
retvalu = DBLMAX
else:
retvalu = ligamma(aa, xx) / tgamma(aa)
return (retvalu)
def ruigamma(aa, xx):
if (aa <= 0.0):
retvalu = DBLMAX
elif (xx <= 0.0):
retvalu = 1.0
else:
retvalu = uigamma(aa, xx) / tgamma(aa)
return (retvalu)
def uigamma__1(aa, xx):
if (xx <= 0.0 or aa <= 0.0):
retvalu = 1.0
else:
ax = aa * math.log(xx) - xx - lgamma(aa)
if (ax < - DBLMAXLN):
retvalu = 0.0
else:
ax = math.exp(ax)
if (xx < 1.0 or xx < aa):
rr = aa
cc = 1.0
ans = 1.0
while True:
rr += 1.0
cc *= xx / rr
ans += cc
if (cc / ans < DBLEPS):
break# loop AWAIT
retvalu = 1.0 - ans * ax / aa
else:
yy = 1.0 - aa
zz = xx + yy + 1.0
cc = 0.0
pkmb = 1.0
qkmb = xx
pkma = xx + 1.0
qkma = zz * xx
ans = pkma / qkma
while True:
cc += 1.0
yy += 1.0
zz += 2.0
yc = yy * cc
pk = pkma * zz - pkmb * yc
qk = qkma * zz - qkmb * yc
if (not iszero(qk)):
rr = pk / qk
tt = math.fabs((ans - rr) / rr)
ans = rr
else:
tt = 1.0
pkmb = pkma
pkma = pk
qkmb = qkma
qkma = qk
if (1.0 / DBLEPS < math.fabs(pk)):
pkmb *= DBLEPS
pkma *= DBLEPS
qkmb *= DBLEPS
qkma *= DBLEPS
if (tt <= DBLEPS):
break# loop AWAIT
retvalu = ans * ax
return (retvalu)
def uigammainv(aa, yy):
dd = 1.0 / (9.0 * aa)
tt = 1.0 - dd - gau_quantile(yy) * math.sqrt(dd)
xx = aa * math.pow(tt, 3)
scvx_dx = 0.1
scvx_xx = xx
scvx_yy = yy - uigamma(aa, scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = yy - uigamma(aa, scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def ligammainv(aa, yy):
return (uigammainv(aa, 1.0 - yy))
def lbeta(aa, bb):
return (lgamma(aa) + lgamma(bb) - lgamma(aa + bb))
def beta(aa, bb):
lbe = lbeta(aa, bb)
if (DBLMAXLN < lbe):
retvalu = DBLMAX
elif (- DBLMAXLN < lbe):
retvalu = math.exp(lbe)
else:
retvalu = -DBLMAX
return (retvalu)
def betainc(aa, bb, xx):
if (xx <= 0.0):
retvalu = 0.0
elif (aa <= 0.0 or bb <= 0.0 or 1.0 <= xx):
retvalu = 1.0
else:
psq = aa + bb
if (aa < psq * xx):
new_xx = 1.0 - xx
compx = xx
pp = bb
qq = aa
indx = 0
else:
new_xx = xx
compx = 1.0 - xx
pp = aa
qq = bb
indx = 1
term = 1.0
sum_curr = 1.0
ai = 1.0
ns = floor(qq + compx * psq)
rx = new_xx / compx
temp = qq - ai
if (ns == 0):
rx = new_xx
while True:
term *= temp * rx / (pp + ai)
ai += 1.0
ns -= 1
if (0 <= ns):
temp = qq - ai
if (ns == 0):
rx = new_xx
else:
temp = psq
psq += 1.0
sum_prev = sum_curr
sum_curr += term
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
log_beta = lgamma(aa) + lgamma(bb) - lgamma(aa + bb)
retvalu = sum_curr * math.exp(pp * math.log(new_xx) + (qq - 1.0) *\
math.log(compx) - log_beta) / pp
if (indx == 0):
retvalu = 1.0 - retvalu
return (retvalu)
def betainc__1(aa, bb, xx):
if (xx <= 0.0):
retvalu = 0.0
elif (aa <= 0.0 or bb <= 0.0 or 1.0 <= xx):
retvalu = 1.0
elif ((aa + 1.0) / (aa + bb + 2.0) < xx):
retvalu = 1.0 - betainc__1(bb, aa, 1.0 - xx)
elif (aa <= 0):
retvalu = 0.0
else:
lbeta_ab = lbeta(aa, bb)
front = math.exp(math.log(xx) * aa + math.log(1.0 - xx) * bb -\
lbeta_ab) / aa
ff = 1.0
cc = 1.0
dd = 0.0
jj = 0
ii = 0
while True:
if (ii == 0):
numerator = 1.0
elif (jj == 0):
kk = ii / 2
den = (aa + 2.0 * kk - 1.0) * (aa + 2.0 * kk)
numerator = (kk * (bb - kk) * xx) / den
else:
kk = (ii - 1) / 2
den = (aa + 2.0 * kk) * (aa + 2.0 * kk + 1.0)
numerator = -((aa + kk) * (aa + bb + kk) * xx) / den
dd = 1.0 + numerator * dd
if (math.fabs(dd) < DBLEPS * DBLEPS):
dd = DBLEPS * DBLEPS
dd = 1.0 / dd
cc = 1.0 + numerator / cc
if (math.fabs(cc) < DBLEPS * DBLEPS):
cc = DBLEPS * DBLEPS
cd = cc * dd
ff *= cd
jj = 1 - ii
if (math.fabs(1.0 - cd) < DBLEPS):
break# loop AWAIT
ii += 1
if (200 <= ii):
break# loop AWAIT
retvalu = front * (ff - 1.0)
return (retvalu)
def lf_digamma_gt_zero(xx):
shift = 0.0
sxx = xx
while (sxx < 8.0):
shift -= 1.0 / sxx
sxx += 1.0
rec_xx_sqr = 1.0 / (sxx * sxx)
sumy = 0.0
for ii in range(14, 0, -2):
sumy *= rec_xx_sqr
sumy += - bernoulli(ii) / ii
return ((shift + math.log(sxx) - 1.0 / (2.0 * sxx) + rec_xx_sqr * sumy))
def digamma(xx):
if (xx <= 0.0):
if (isint(xx)):
retvalu = DBLMAX
else:
sxx = 2.0 * xx
retvalu = lf_digamma_gt_zero(1.0 - xx) - PI / math.tan(sxx)
else:
retvalu = lf_digamma_gt_zero(xx)
return (retvalu)
def digammainv(yy):
scvx_dx = 0.1
scvx_xx = math.exp(yy)
scvx_yy = yy - digamma(scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = yy - digamma(scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def lf_digamma_gt_zero__1(xx):
aa_arr = [0 for ii in range(10)]
gg = 9.6565781537733158945718737389
aa_arr[0] = +1.144005294538510956673085217E+4
aa_arr[1] = -3.239880201523183350535979104E+4
aa_arr[2] = +3.505145235055716665660834611E+4
aa_arr[3] = -1.816413095412607026106469185E+4
aa_arr[4] = +4.632329905366668184091382704E+3
aa_arr[5] = -5.369767777033567805557478696E+2
aa_arr[6] = +2.287544733951810076451548089E+1
aa_arr[7] = -2.179257487388651155600822204E-1
aa_arr[8] = +1.083148362725893688606893534E-4
numer = 0.0
denom = 1.0
for ii in range(8, -1, -1):
sxx = xx + ii
term = aa_arr[ii] / sxx
denom += term
numer += term / sxx
lnarg = (gg + xx - 0.5)
return (math.log(lnarg) - (gg / lnarg) - numer / denom)
def digamma__1(xx):
if (xx <= 0.0):
if (isint(xx)):
retvalu = DBLMAX
else:
sxx = 2.0 * xx
retvalu = lf_digamma_gt_zero__1(1.0 - xx) - PI / math.tan(sxx)
else:
retvalu = lf_digamma_gt_zero__1(xx)
return (retvalu)
def factorialinv(yy):
return (tgammainv(yy) - 1.0)
def facinv(yy):
return (tgammainv(yy) - 1.0)
def hn(xx):
if (0.0 < xx):
fxx = floor(xx)
sum = 0.0
for kk in range(fxx, 0, -1):
sum += 1.0 / kk
else:
sum = 0.0
return (sum)
def hn__1(xx):
if (0.0 < xx):
yy = 1.0 / (xx * xx)
retvalu = ((((((-5.0 / (66.0 * 10.0)) * yy + 1.0 / (30.0 * 8.0)) *\
yy - 1.0 / (42.0 * 6.0)) * yy + 1.0 / (30.0 * 4.0)) * yy -\
1.0 / (6.0 * 2.0)) * yy + EULER) + math.log(xx) + 0.5 / xx
else:
retvalu = 0.0
return (retvalu)
def hnm(xx, vv):
fxx = floor(xx)
sum = 0.0
for kk in range(fxx, 0, -1):
sum += 1.0 / math.pow(kk, vv)
return (sum)
lv_factorial_arr = [0 for ii in range(0)]
lv_factorial_end = 0
def factorial(nn):
global lv_factorial_end
global lv_factorial_arr
if (nn < 0):
retvalu = 0
else:
if (lv_factorial_end <= 0):
lv_factorial_end = 6
for nzzn in range(len(lv_factorial_arr), int(lv_factorial_end)):
lv_factorial_arr.append(0)
lv_factorial_arr[0] = 1
lv_factorial_arr[1] = 1
lv_factorial_arr[2] = 2
lv_factorial_arr[3] = 6
lv_factorial_arr[4] = 24
lv_factorial_arr[5] = 120
if (lv_factorial_end <= nn):
ii = lv_factorial_end
lv_factorial_end = nn + 1
for nzzn in range(len(lv_factorial_arr), int(lv_factorial_end)):
lv_factorial_arr.append(0)
while (ii < lv_factorial_end):
lv_factorial_arr[ii] = (ii * lv_factorial_arr[ii - 1])
ii += 1
retvalu = lv_factorial_arr[nn]
return (retvalu)
lv_factorial_b_arr = [0 for ii in range(0)]
lv_factorial_b_end = 0
def factorialdouble(nn):
global lv_factorial_b_end
global lv_factorial_b_arr
if (nn < 0):
retvalu = 0
else:
if (lv_factorial_b_end <= 0):
lv_factorial_b_end = 6
for nzzn in range(len(lv_factorial_b_arr), int(lv_factorial_b_end)):
lv_factorial_b_arr.append(0)
lv_factorial_b_arr[0] = 1
lv_factorial_b_arr[1] = 1
lv_factorial_b_arr[2] = 2
lv_factorial_b_arr[3] = 3
lv_factorial_b_arr[4] = 8
lv_factorial_b_arr[5] = 15
if (lv_factorial_b_end <= nn):
ii = lv_factorial_b_end
lv_factorial_b_end = nn + 1
for nzzn in range(len(lv_factorial_b_arr), int(lv_factorial_b_end)):
lv_factorial_b_arr.append(0)
while (ii < lv_factorial_b_end):
lv_factorial_b_arr[ii] = ii * lv_factorial_b_arr[ii - 2]
ii += 1
retvalu = lv_factorial_b_arr[nn]
return (retvalu)
def fac(nn):
return (factorial(nn))
def factorialt(n_things, r_each):
retvalu = 1.0
for ii in range(r_each + 1, n_things + 1, 1):
retvalu *= ii
return (retvalu)
def comb(n_things, r_each):
if (r_each < 0 or n_things < r_each):
retvalu = 0.0
else:
if (2 * r_each < n_things):
r_each = n_things - r_each
retvalu = 1.0
for ii in range(r_each + 1, n_things + 1, 1):
retvalu *= ii
retvalu /= (ii - r_each)
return (retvalu)
def perm(n_things, r_each):
return (factorialt(n_things, n_things - r_each))
def combination(n_things, r_each):
return (comb(n_things, r_each))
def permutation(n_things, r_each):
return (perm(n_things, r_each))
lv_catalan_arr = [0 for ii in range(0)]
lv_catalan_end = 0
def catalan(nn):
global lv_catalan_end
global lv_catalan_arr
if (nn < 0):
retvalu = 0
else:
if (lv_catalan_end <= 0):
lv_catalan_end = 1
for nzzn in range(len(lv_catalan_arr), int(lv_catalan_end)):
lv_catalan_arr.append(0)
lv_catalan_arr[0] = 1
if (lv_catalan_end <= nn):
kk = lv_catalan_end
lv_catalan_end = nn + 1
for nzzn in range(len(lv_catalan_arr), int(lv_catalan_end)):
lv_catalan_arr.append(0)
while (kk < lv_catalan_end):
lv_catalan_arr[kk] = (2.0 * (2.0 * kk - 1.0) *\
lv_catalan_arr[kk - 1] / (kk + 1.0))
kk += 1
retvalu = lv_catalan_arr[nn]
return (retvalu)
lv_supercatalan_arr = [0 for ii in range(0)]
lv_supercatalan_end = 0
def supercatalan(nn):
global lv_supercatalan_end
global lv_supercatalan_arr
if (nn < 0):
retvalu = 0
else:
if (lv_supercatalan_end <= 0):
lv_supercatalan_end = 3
for nzzn in range(len(lv_supercatalan_arr),\
int(lv_supercatalan_end)):
lv_supercatalan_arr.append(0)
lv_supercatalan_arr[0] = 1
lv_supercatalan_arr[1] = 1
lv_supercatalan_arr[2] = 1
if (lv_supercatalan_end <= nn):
kk = lv_supercatalan_end
lv_supercatalan_end = nn + 1
for nzzn in range(len(lv_supercatalan_arr),\
int(lv_supercatalan_end)):
lv_supercatalan_arr.append(0)
while (kk < lv_supercatalan_end):
lv_supercatalan_arr[kk] = (((6 * kk - 9) *\
lv_supercatalan_arr[kk - 1] - (kk - 3) *\
lv_supercatalan_arr[kk - 2]) / kk)
kk += 1
retvalu = lv_supercatalan_arr[nn]
return (retvalu)
lv_bell_arr = [0 for ii in range(0)]
lv_bell_x_arr = [0 for ii in range(0)]
lv_bell_end = 0
def bell(nn):
global lv_bell_end
global lv_bell_arr
global lv_bell_x_arr
if (nn < 0):
retvalu = 0
else:
if (lv_bell_end <= 0):
lv_bell_end = 3
for nzzn in range(len(lv_bell_arr), int(lv_bell_end)):
lv_bell_arr.append(0)
for nzzn in range(len(lv_bell_x_arr), int(lv_bell_end - 1)):
lv_bell_x_arr.append(0)
lv_bell_arr[0] = 1
lv_bell_arr[1] = 1
lv_bell_arr[2] = 2
lv_bell_x_arr[0] = 2
lv_bell_x_arr[1] = 1
if (lv_bell_end <= nn):
kk = lv_bell_end
lv_bell_end = nn + 1
for nzzn in range(len(lv_bell_arr), int(lv_bell_end)):
lv_bell_arr.append(0)
for nzzn in range(len(lv_bell_x_arr), int(lv_bell_end - 1)):
lv_bell_x_arr.append(0)
while (kk < lv_bell_end):
lv_bell_x_arr[kk - 1] = lv_bell_x_arr[0]
for jj in range(kk - 2, -1, -1):
lv_bell_x_arr[jj] += lv_bell_x_arr[jj + 1]
lv_bell_arr[kk] = lv_bell_x_arr[0]
kk += 1
retvalu = lv_bell_arr[nn]
return (retvalu)
def bellx(xxn):
kk = 0
sum = 0.0
den = 1.0
while True:
kk += 1
den *= kk
sum_prev = sum
sum += math.pow(kk, xxn) / den
if (iseq(sum_prev, sum)):
break# loop AWAIT
return (sum / E)
def fubini(nn):
if (nn < 0):
retvalu = 0
elif (nn == 0):
retvalu = 1
else:
sum = 1.0 / (2.0 * TWOLN * TWOLN)
for ii in range(2, nn + 1, 1):
sum *= ii / TWOLN
retvalu = round(sum)
return (retvalu)
def d2lt_d1(xx, yy):
if (0 <= yy and yy <= xx):
retvalu = yy + (xx * (xx + 1)) / 2
else:
retvalu = -1
return int(retvalu)
def d1lt_d2(nn, ret_arr_p):
if (nn <= 0):
ret_arr_p[0] = 0
ret_arr_p[1] = 0
else:
basee = floorl((math.sqrt(1 + 8.0 * nn) - 1) / 2)
ret_arr_p[1] = nn - basee * (basee + 1) / 2
ret_arr_p[0] = basee
return int(ret_arr_p[0])
def d2ur_d1(xx, yy):
if (0 <= xx and 0 <= yy):
suma = (yy + xx)
retvalu = suma * (suma + 1) / 2 + yy
else:
retvalu = -1
return int(retvalu)
def d1ur_d2(nn, ret_arr_p):
if (nn <= 0):
ret_arr_p[0] = 0
ret_arr_p[1] = 0
else:
basee = floorl((math.sqrt(1 + 8.0 * nn) - 1) / 2)
y_coord = nn - basee * (basee + 1) / 2
ret_arr_p[1] = y_coord
ret_arr_p[0] = basee - y_coord
return int(ret_arr_p[0])
def d2diamond_d1(xx, yy):
if (0 == yy and xx == 0):
retvalu = 0
else:
ss = math.fabs(xx) + math.fabs(yy)
tt = 2 * ss * (ss - 1) + 1
if (0 < xx):
retvalu = tt + ss + yy - 1
else:
retvalu = tt + 3 * ss - yy - 1
return int(retvalu)
def d1diamond_d2(nn, ret_arr_p):
if (nn <= 0):
x_coord = 0
ret_arr_p[1] = 0
else:
ss = floorl(math.sqrt(nn) / TWOSQRT)
ssq = 2 * ss * ss
if (nn <= ssq + 2 * ss):
ret_arr_p[1] = ssq - nn + ss
x_coord = ssq - nn
if (ss < - x_coord):
x_coord = -x_coord - 2 * ss
else:
ret_arr_p[1] = nn - ssq - 3 * ss - 1
x_coord = nn - ssq - 2 * ss
if (ss < x_coord):
x_coord = -x_coord + 2 * ss + 2
ret_arr_p[0] = x_coord
return int(x_coord)
def d2spiral_d1(xx, yy):
if (xx == 0 and yy == 0):
retvalu = 0
elif (math.fabs(xx) <= math.fabs(yy)):
retvalu = (4 * yy - 1) * yy - xx
if (yy < 0):
retvalu -= 2 * (yy - xx)
else:
retvalu = (4 * xx - 1) * xx - yy
if (0 < xx):
retvalu -= 2 * (xx - yy)
return int(retvalu)
def d1spiral_d2(nn, ret_arr_p):
if (nn <= 0):
ret_arr_p[0] = 0
ret_arr_p[1] = 0
else:
sqrtnn = floorl(math.sqrt(nn))
if (iseven(sqrtnn)):
fxd = -sqrtnn / 2
else:
fxd = (sqrtnn + 1) / 2
newdd = nn - sqrtnn * sqrtnn
if (newdd <= sqrtnn):
ret_arr_p[0] = fxd
if (fxd < 0):
ret_arr_p[1] = -fxd - newdd
else:
ret_arr_p[1] = -fxd + newdd + 1
else:
ret_arr_p[1] = fxd
newdd -= sqrtnn
if (fxd < 0):
ret_arr_p[0] = fxd + newdd
else:
ret_arr_p[0] = fxd - newdd
return int(ret_arr_p[0])
def d2hypot_d1(xx, yy):
if (0 <= yy and yy <= xx):
distsq = xx * xx + yy * yy
dist = math.sqrt(distsq)
xlim = floorl(dist / TWOSQRT)
xmax = floorl(dist)
count = 0
for ixx in range(xlim, xmax + 1, 1):
nyysq = distsq - ixx * ixx
nyy = ceill(math.sqrt(nyysq))
if (ixx < nyy):
count += ixx + 1
else:
count += nyy
if (ixx < xx and nyy * nyy == nyysq):
count += 1
retvalu = count + (xlim) * (xlim + 1) / 2
else:
retvalu = -1
return int(retvalu)
def binomialx(xnn, xkk):
return (tgamma(xnn + 1) / (tgamma(xkk + 1) * tgamma(xnn + 1 - xkk)))
lv_binom_arr = [0 for ii in range(0)]
lv_binom_end = 0
lv_binom_max = 0
def binomial(nn, kk):
global lv_binom_arr
global lv_binom_end
global lv_binom_max
if (nn < kk or nn < 0 or kk < 0):
retvalu = 0
else:
if (lv_binom_end <= 0):
lv_binom_max = 2
lv_binom_end = d2lt_d1(lv_binom_max, 0)
for nzzn in range(len(lv_binom_arr), int(lv_binom_end)):
lv_binom_arr.append(0)
lv_binom_arr[0] = 1
lv_binom_arr[1] = 1
lv_binom_arr[2] = 1
rr = lv_binom_max
if (rr < nn + 1):
lv_binom_end = d2lt_d1(nn + 1, 0)
for nzzn in range(len(lv_binom_arr), int(lv_binom_end)):
lv_binom_arr.append(0)
while (rr <= nn):
ul_ind = d2lt_d1(rr - 1, 0)
lz_ind = ul_ind + rr
lv_binom_arr[lz_ind] = 1
rz_ind = lz_ind + rr
while (lz_ind < rz_ind):
lv_binom_arr[rz_ind] = lv_binom_arr[lz_ind]
rz_ind -= 1
lz_ind += 1
lv_binom_arr[lz_ind] = (lv_binom_arr[ul_ind] +\
lv_binom_arr[ul_ind + 1])
ul_ind += 1
rr += 1
lv_binom_max = rr
retvalu = lv_binom_arr[d2lt_d1(nn, kk)]
return int(retvalu)
lv_euler_arr = [0 for ii in range(0)]
lv_euler_end = 0
lv_euler_max = 0
def eulerian(nn, kk):
global lv_euler_arr
global lv_euler_end
global lv_euler_max
if (nn < kk or nn < 0 or kk < 0):
retvalu = 0
else:
if (lv_euler_end <= 0):
lv_euler_max = 3
lv_euler_end = d2lt_d1(lv_euler_max, 0)
for nzzn in range(len(lv_euler_arr), int(lv_euler_end)):
lv_euler_arr.append(0)
lv_euler_arr[0] = 0
lv_euler_arr[1] = 1
lv_euler_arr[2] = 0
lv_euler_arr[3] = 1
lv_euler_arr[4] = 1
lv_euler_arr[5] = 0
ii = lv_euler_max
if (ii < nn + 1):
lv_euler_end = d2lt_d1(nn + 1, 0)
for nzzn in range(len(lv_euler_arr), int(lv_euler_end)):
lv_euler_arr.append(0)
while (ii <= nn):
lz_ind = d2lt_d1(ii, 0)
lv_euler_arr[lz_ind] = 1
lv_euler_arr[lz_ind + ii] = 0
rz_ind = lz_ind + ii - 1
ul_ind = d2lt_d1(ii - 1, 0)
jj = 1
while (lz_ind < rz_ind):
lv_euler_arr[rz_ind] = lv_euler_arr[lz_ind]
lz_ind += 1
lv_euler_arr[lz_ind] = ((ii - jj) * lv_euler_arr[ul_ind] +\
(jj + 1) * lv_euler_arr[ul_ind + 1])
ul_ind += 1
rz_ind -= 1
jj += 1
ii += 1
lv_euler_max = ii
retvalu = lv_euler_arr[d2lt_d1(nn, kk)]
return (retvalu)
lv_entringer_arr = [0 for ii in range(0)]
lv_entringer_end = 0
lv_entringer_max = 0
def entringer(nn, kk):
global lv_entringer_arr
global lv_entringer_max
global lv_entringer_end
if (nn <= 0 or kk < 0 or nn < kk):
retvalu = 0
else:
if (lv_entringer_end <= 0):
lv_entringer_max = 1
lv_entringer_end = d2lt_d1(lv_entringer_max, 0)
for nzzn in range(len(lv_entringer_arr), int(lv_entringer_end)):
lv_entringer_arr.append(0)
lv_entringer_arr[0] = 1
jj = lv_entringer_max
if (jj < nn + 1):
lv_entringer_end = d2lt_d1(nn + 1, 0)
for nzzn in range(len(lv_entringer_arr), int(lv_entringer_end)):
lv_entringer_arr.append(0)
while (jj <= nn):
inda = d2lt_d1(jj, 0)
lv_entringer_arr[inda] = 0
for ii in range(1, jj + 1, 1):
lv_entringer_arr[inda + ii] = lv_entringer_arr[inda - ii]\
+ lv_entringer_arr[inda + ii - 1]
jj += 1
lv_entringer_max = jj
retvalu = lv_entringer_arr[d2lt_d1(nn, kk)]
return (retvalu)
def zigzag(nn):
return (entringer(nn, nn))
def zig(nn):
return (zigzag(2 * nn))
def zag(nn):
return (zigzag(2 * nn - 1))
def eulerx(nn):
if (nn <= 0 or isodd(nn)):
retvalu = 0
else:
retvalu = entringer(nn, nn)
return (retvalu)
def ballot(xmm, xnn):
return (math.fabs(xnn - xmm) / (xmm + xnn))
def ballots(xmm, xnn):
if (xmm < xnn):
retvalu = (xnn - xmm + 1.0) / (xnn + 1.0)
else:
retvalu = (xmm - xnn + 1.0) / (xmm + 1.0)
return (retvalu)
lv_stir_a_arr = [0 for ii in range(0)]
lv_stir_a_end = 0
lv_stir_a_max = 0
def stirling1(nn, kk):
global lv_stir_a_arr
global lv_stir_a_end
global lv_stir_a_max
if (nn < 0 or kk < 0 or nn < kk):
retvalu = 0
else:
if (lv_stir_a_max <= 0):
lv_stir_a_max = 2
lv_stir_a_end = d2lt_d1(lv_stir_a_max, 0)
for nzzn in range(len(lv_stir_a_arr), int(lv_stir_a_end)):
lv_stir_a_arr.append(0)
lv_stir_a_arr[0] = 1
lv_stir_a_arr[1] = 0
lv_stir_a_arr[2] = 1
ii = lv_stir_a_max
if (ii < nn + 1):
lv_stir_a_end = d2lt_d1(nn + 1, 0)
for nzzn in range(len(lv_stir_a_arr), int(lv_stir_a_end)):
lv_stir_a_arr.append(0)
while (ii <= nn):
cz_ind = d2lt_d1(ii, 0)
lv_stir_a_arr[cz_ind] = 0
cz_ind += 1
ul_ind = d2lt_d1(ii - 1, 0)
for col_k in range(1, ii + 0, 1):
lv_stir_a_arr[cz_ind] = (lv_stir_a_arr[ul_ind] - (ii - 1)\
* lv_stir_a_arr[ul_ind + 1])
ul_ind += 1
cz_ind += 1
lv_stir_a_arr[cz_ind] = 1
ii += 1
lv_stir_a_max = ii
retvalu = lv_stir_a_arr[d2lt_d1(nn, kk)]
return (retvalu)
lv_stir_b_arr = [0 for ii in range(0)]
lv_stir_b_end = 0
lv_stir_b_max = 0
def stirling2(nn, kk):
global lv_stir_b_arr
global lv_stir_b_end
global lv_stir_b_max
if (nn < kk or nn < 0 or kk < 0):
retvalu = 0
else:
if (lv_stir_b_end <= 0):
lv_stir_b_max = 2
lv_stir_b_end = d2lt_d1(lv_stir_b_max, 0)
for nzzn in range(len(lv_stir_b_arr), int(lv_stir_b_end)):
lv_stir_b_arr.append(0)
lv_stir_b_arr[0] = 1
lv_stir_b_arr[1] = 0
lv_stir_b_arr[2] = 1
ii = lv_stir_b_max
if (ii < nn + 1):
lv_stir_b_end = d2lt_d1(nn + 1, 0)
for nzzn in range(len(lv_stir_b_arr), int(lv_stir_b_end)):
lv_stir_b_arr.append(0)
while (ii <= nn):
cz_ind = d2lt_d1(ii, 0)
lv_stir_b_arr[cz_ind] = 0
cz_ind += 1
ul_ind = d2lt_d1(ii - 1, 0)
for col_k in range(1, ii + 0, 1):
lv_stir_b_arr[cz_ind] = (lv_stir_b_arr[ul_ind] + col_k *\
lv_stir_b_arr[ul_ind + 1])
ul_ind += 1
cz_ind += 1
lv_stir_b_arr[cz_ind] = 1
ii += 1
lv_stir_b_max = ii
retvalu = lv_stir_b_arr[d2lt_d1(nn, kk)]
return (retvalu)
lv_bern_n_arr = [0 for ii in range(0)]
lv_bern_d_arr = [0 for ii in range(0)]
lv_bern_end = 0
def bernoulli(nn):
global lv_bern_n_arr
global lv_bern_d_arr
global lv_bern_end
if (nn == 1):
retvalu = -0.5
elif (nn < 0 or isodd(nn)):
retvalu = 0.0
else:
if (lv_bern_end <= 0):
lv_bern_end = 3
for nzzn in range(len(lv_bern_n_arr), int(lv_bern_end)):
lv_bern_n_arr.append(0)
for nzzn in range(len(lv_bern_d_arr), int(lv_bern_end)):
lv_bern_d_arr.append(0)
lv_bern_n_arr[0] = 1
lv_bern_n_arr[1] = 1
lv_bern_n_arr[2] = -1
lv_bern_d_arr[0] = 1
lv_bern_d_arr[1] = 6
lv_bern_d_arr[2] = 30
nnhalf = floorl(nn / 2)
if (lv_bern_end <= nnhalf):
ii = lv_bern_end
lv_bern_end = nnhalf + 1
for nzzn in range(len(lv_bern_n_arr), int(lv_bern_end)):
lv_bern_n_arr.append(0)
for nzzn in range(len(lv_bern_d_arr), int(lv_bern_end)):
lv_bern_d_arr.append(0)
while (ii < lv_bern_end):
sz_ind = 2 * ii
coeff = ((sz_ind + 1) * sz_ind) / 2
sumn = 1.0 - sz_ind
sumd = 2.0
for jj in range(1, ii + 0, 1):
nsumn = round(sumn * lv_bern_d_arr[jj] + sumd * coeff *\
lv_bern_n_arr[jj])
nsumd = round(sumd * lv_bern_d_arr[jj])
gdn = gcd(nsumn, nsumd)
sumn = nsumn / gdn
sumd = nsumd / gdn
xkk = 2 * jj
coeff *= (sz_ind - xkk + 1.0) / (xkk + 1.0)
coeff *= (sz_ind - xkk) / (xkk + 2.0)
coeff = round(coeff)
sumd *= (sz_ind + 1)
gdn = gcd(sumn, sumd)
lv_bern_n_arr[ii] = -sumn / gdn
lv_bern_d_arr[ii] = sumd / gdn
ii += 1
retvalu = lv_bern_n_arr[nnhalf] / lv_bern_d_arr[nnhalf]
return (retvalu)
def bernoullin(nn):
global lv_bern_n_arr
global lv_bern_d_arr
if (nn == 1):
retvalu = -1
elif (isodd(nn) or nn < 0):
retvalu = 0
else:
retvalu = bernoulli(nn)
retvalu = lv_bern_n_arr[nn / 2]
return int(retvalu)
def bernoullid(nn):
global lv_bern_n_arr
global lv_bern_d_arr
if (nn == 1):
retvalu = 2
elif (isodd(nn) or nn < 0):
retvalu = 1
else:
retvalu = bernoulli(nn)
retvalu = lv_bern_d_arr[nn / 2]
return int(retvalu)
def birthday(xnn, xrr):
prob = 1.0
for ii in range(1, xrr + 0, 1):
prob *= (xnn - ii) / xnn
return (prob)
def birthdayinv(xnn, xprob):
cprob = 1.0
xrr = 1.0
while (xprob < cprob):
cprob *= (xnn - xrr) / xnn
xrr += 1
return (xrr)
def n2perm(nth, nn, ret_perm_arr_p):
pat_arr = []
source_arr = []
for nzzn in range(len(pat_arr), int(nn)):
pat_arr.append(0)
for nzzn in range(len(source_arr), int(nn)):
source_arr.append(0)
nthmod = modulo(nth, factorial(nn))
kk = nthmod
for ii in range(1, nn + 1, 1):
pat_arr[nn - ii] = kk % ii
kk = floor(kk / ii)
source_arr[ii - 1] = ii - 1
for ii in range(0, nn + 0, 1):
sz_ind = pat_arr[ii]
ret_perm_arr_p[ii] = source_arr[sz_ind]
for jj in range(sz_ind, nn - ii - 1, 1):
source_arr[jj] = source_arr[jj + 1]
return int(nthmod)
def n2comb(nth, nn, rr, ret_comb_arr_p):
nthmod = modulo(nth, comb(nn, rr))
kk = comb(nn, rr) - nthmod
for ss in range(0, rr + 0, 1):
pp = rr - ss
cc = 1
qq = 1
while (cc < kk):
kk -= cc
cc = (cc * pp) / qq
qq += 1
pp += 1
ret_comb_arr_p[ss] = nn - pp
return int(nthmod)
def n2perm_print(nth, nn):
perm_arr = []
for nzzn in range(len(perm_arr), int(nn)):
perm_arr.append(0)
jj = n2perm(nth, nn, perm_arr)
print_array(nn, perm_arr)
return int(jj)
def n2comb_print(nth, nn, rr):
comb_arr = []
for nzzn in range(len(comb_arr), int(rr)):
comb_arr.append(0)
jj = n2comb(nth, nn, rr, comb_arr)
print_array(rr, comb_arr)
return int(jj)
def pochhammer(nn, xx):
if (0 < nn):
retvalu = xx
for ii in range(1, nn + 1, 1):
retvalu *= (xx + ii)
elif (nn < 0):
retvalu = xx
for ii in range(- 1, nn - 1, -1):
retvalu *= (xx + ii)
else:
retvalu = 1.0
return (retvalu)
def days_in_month(g_year, g_month):
if (g_month == 2):
if (isleapyear(g_year)):
retvalu = 29
else:
retvalu = 28
elif ((6 * g_month + 1) % 11 < 5):
retvalu = 30
else:
retvalu = 31
return int(retvalu)
def sec2dhms(seconds):
if (seconds < 0.0):
sg = -1.0
else:
sg = 1.0
dy = floor(seconds * SECOND / DAY)
tm = (seconds * SECOND / DAY - dy) * DAY / HOUR
hr = floor(tm)
tm = (tm - hr) * HOUR / MINUTE
mn = floor(tm)
tm = (tm - mn) * MINUTE / SECOND
return (dy + sg * (hr + (mn + tm / 100.0) / 100.0) / 100.0)
def day2dhms(dayfrac):
if (dayfrac < 0.0):
sg = -1.0
else:
sg = 1.0
dy = floor(dayfrac)
tm = (dayfrac - dy) * DAY / HOUR
hr = floor(tm)
tm = (tm - hr) * HOUR / MINUTE
mn = floor(tm)
tm = (tm - mn) * MINUTE / SECOND
return (dy + sg * (hr + (mn + tm / 100.0) / 100.0) / 100.0)
def day2dhmsinv(xx_hms):
dy = floor(xx_hms)
tm = (xx_hms - dy) * 100.0
hr = floor(tm)
tm = (tm - hr) * 100.0
mn = floor(tm)
tm = (tm - mn) * 100.0
return (dy + (hr * HOUR + mn * MINUTE + tm * SECOND) / DAY)
def hms2day(hourx, minutex, secondx):
return ((secondx * SECOND + minutex * MINUTE + hourx * HOUR) / DAY)
def hour2day(hourx):
return (hourx * HOUR / DAY)
def day2hour(dayx):
return (dayx * DAY / HOUR)
def jd2kwt(jjdtime):
return ((jjdtime * JDAY - JDSEC_AT_0KWT) / KWT)
def jd2j2k(jjdtime):
return ((jjdtime * JDAY - JDSEC_AT_0J2K) / J2KDAY)
def jd2uet(jjdtime):
return ((jjdtime * JDAY - JDSEC_AT_0UET) / UET)
def kwt2jd(kwttime):
return ((kwttime * KWT + JDSEC_AT_0KWT) / JDAY)
def uet2jd(uettime):
return ((uettime * UET + JDSEC_AT_0UET) / JDAY)
def j2k2jd(jtwoktm):
return ((jtwoktm * J2KDAY + JDSEC_AT_0J2K) / JDAY)
def j2k2kwt(jtwoktm):
return (jd2kwt(j2k2jd(jtwoktm)))
def j2k2uet(jtwoktm):
return (jd2uet(j2k2jd(jtwoktm)))
def kwt2j2k(kwttime):
return (jd2j2k(kwt2jd(kwttime)))
def kwt2uet(kwttime):
return (jd2uet(kwt2jd(kwttime)))
def uet2kwt(uettime):
return (jd2kwt(uet2jd(uettime)))
def uet2j2k(uettime):
return (jd2j2k(uet2jd(uettime)))
def jd2dow(jjd):
jjtemp = floor(jjd + 1.5)
return int(jjtemp % 7)
def j2k2dow(jtwok):
jjtemp = floor(jtwok + 6.5)
return int(jjtemp % 7)
def ymd2doy(g_year, g_month, g_daymon):
if (2 < g_month):
delta = floor(30.6001 * g_month - 32.3)
if (isleapyear(g_year)):
delta += 1
elif (g_month == 2):
delta = 31
else:
delta = 0
return (delta + g_daymon)
def ymd2j2k__1(g_year, g_month, g_day):
yr = g_year - GYEAR_AT_0J2K
mn = g_month
if (mn < 3):
mn += MONTHS_IN_YEAR
yr -= 1
jcen = floor(yr / 100)
dayoffset = jcen - floor(jcen / 4.0) + 31.3
jtwok = (floor(yr * JYEAR / JDAY) + floor(30.6001 * mn - dayoffset) +\
g_day - 1.5)
return (jtwok)
def ymd2j2k(g_year, g_month, g_day):
yr = g_year - GYEAR_AT_0J2K
mn = g_month
jcen = floor((yr - 1) / 100)
jtwok = (floor(yr * JYEAR / JDAY - 0.001) + floor(jcen / 4.0) - jcen +\
ymd2doy(yr, mn, g_day) - 0.5)
return (jtwok)
def ymd2jd(g_year, g_month, g_day):
return (j2k2jd(ymd2j2k(g_year, g_month, g_day)))
def ymd2dow(g_year, g_month, g_daymon):
return int((jd2dow(ymd2jd(g_year, g_month, g_daymon))))
def doomsday(g_year):
cc = floor(g_year / 100)
anchor = (cc % 4) * 5 + 2
yy = g_year % 100
lps = floor(yy / 4)
retvalu = (anchor + yy + lps) % 7
return int(retvalu)
LC_GD_YEAR = 0
LC_GD_MONTH = 1
LC_GD_DAY = 2
LC_GD_HOUR = 3
LC_GD_MIN = 4
LC_GD_SEC = 5
LC_GD_DOW = 6
LC_GD_NUM = 7
LC_GD_JD = 8
LC_GD_CNT = 9
lv_ymdhms_arr = [0 for ii in range(20)]
def jd2ymdhms(jjulid):
global lv_ymdhms_arr
lv_ymdhms_arr[LC_GD_JD] = jjulid
ftime_frac = frac(jjulid + 0.5)
ijulian = floor(jjulid + 0.5)
jcent = floor(((ijulian - 60.5) * JDAY - JDSEC_AT_0GREGORIAN) / (100.0\
* GYEAR))
bbdays = ijulian + jcent - floor(jcent / 4.0)
g_years = floor((bbdays + 1399.9) * JDAY / JYEAR)
bdiff = bbdays - floor(g_years * JYEAR / JDAY) + 1522
month_next = floor(bdiff / 30.6001)
dtime_rem = bdiff - floor(30.6001 * month_next) + ftime_frac
lv_ymdhms_arr[LC_GD_YEAR] = g_years - 4716.0
if (13 < month_next):
lv_ymdhms_arr[LC_GD_MONTH] = month_next - 13
else:
lv_ymdhms_arr[LC_GD_MONTH] = month_next - 1
if (lv_ymdhms_arr[LC_GD_MONTH] < 3):
lv_ymdhms_arr[LC_GD_YEAR] += 1
lv_ymdhms_arr[LC_GD_DAY] = floor(dtime_rem)
dtime_rem = DAY / HOUR * frac(dtime_rem)
lv_ymdhms_arr[LC_GD_HOUR] = floor(dtime_rem)
dtime_rem = HOUR / MINUTE * frac(dtime_rem)
lv_ymdhms_arr[LC_GD_MIN] = floor(dtime_rem)
dtime_rem = MINUTE / SECOND * frac(dtime_rem)
lv_ymdhms_arr[LC_GD_SEC] = dtime_rem
lv_ymdhms_arr[LC_GD_DOW] = floor(fmod(ijulian + 1.0, 7.0))
dtime_rem = (lv_ymdhms_arr[LC_GD_MONTH] * 100.0 +\
lv_ymdhms_arr[LC_GD_DAY] + lv_ymdhms_arr[LC_GD_HOUR] / 100.0\
+ lv_ymdhms_arr[LC_GD_MIN] / 10000.0 +\
lv_ymdhms_arr[LC_GD_SEC] / 1000000.0)
ftime_frac = lv_ymdhms_arr[LC_GD_YEAR] * 10000.0
if (ftime_frac < 0.0):
lv_ymdhms_arr[LC_GD_NUM] = ftime_frac - dtime_rem
else:
lv_ymdhms_arr[LC_GD_NUM] = ftime_frac + dtime_rem
return (lv_ymdhms_arr[LC_GD_NUM])
def j2k2ymdhms(jtwokd):
return (jd2ymdhms(j2k2jd(jtwokd)))
def ymdhms_get(indexp):
global lv_ymdhms_arr
if (LC_GD_YEAR <= indexp and indexp < LC_GD_CNT):
retvalu = lv_ymdhms_arr[indexp]
else:
retvalu = -1
return (retvalu)
def jd2ymdhmsinv():
global lv_ymdhms_arr
return (ymd2jd(lv_ymdhms_arr[LC_GD_YEAR], lv_ymdhms_arr[LC_GD_MONTH],\
lv_ymdhms_arr[LC_GD_DAY]) + hms2day(lv_ymdhms_arr[LC_GD_HOUR]\
, lv_ymdhms_arr[LC_GD_MIN], lv_ymdhms_arr[LC_GD_SEC]) * DAY /\
JDAY)
def jd264_print(jjulid):
jd2ymdhms(jjulid)
base_out_print(ymdhms_get(LC_GD_YEAR), 64)
base_out_print(ymdhms_get(LC_GD_MONTH), 64)
base_out_print(ymdhms_get(LC_GD_DAY), 64)
base_out_print(ymdhms_get(LC_GD_HOUR), 64)
base_out_print(ymdhms_get(LC_GD_MIN), 64)
base_outf_print(ymdhms_get(LC_GD_SEC), 64)
return (jjulid)
def ymdhms2jd(ymdhmsx):
xx_arr = [0 for ii in range(LC_GD_CNT)]
ys = ymdhmsx * (1.0 + DBLEPS)
xx_arr[LC_GD_YEAR] = floor(ys / 10000.0)
if (ys < 0):
ys = -ys
xx_arr[LC_GD_MONTH] = fmodu(floor(ys / 100.0), 100.0)
xx_arr[LC_GD_DAY] = fmodu(floor(ys), 100.0)
xx_arr[LC_GD_HOUR] = fmodu(floor(ys * 100.0), 100.0)
xx_arr[LC_GD_MIN] = fmodu(floor(ys * 10000.0), 100.0)
xx_arr[LC_GD_SEC] = frac(ys * 10000.0) * 100.0
return (ymd2jd(xx_arr[LC_GD_YEAR], xx_arr[LC_GD_MONTH],\
xx_arr[LC_GD_DAY]) + hms2day(xx_arr[LC_GD_HOUR],\
xx_arr[LC_GD_MIN], xx_arr[LC_GD_SEC]) * DAY / JDAY)
def ymdhms2j2k(ymdhmsx):
return (jd2j2k(ymdhms2jd(ymdhmsx)))
def clocksec(secnds):
return (frac(secnds / MINUTE) * TAU)
def clockmin(secnds):
return (frac(secnds / HOUR) * TAU)
def clockhour(secnds):
return (frac(secnds / (DAY / 2)) * TAU)
def clocksum(secnds):
sc = clocksec(secnds)
mn = clockmin(secnds)
hr = clockhour(secnds)
return (dist(sc - mn, TAU) + dist(hr - mn, TAU) + dist(sc - hr, TAU))
def clockstdev(secnds):
sc = clocksec(secnds)
mn = clockmin(secnds)
hr = clockhour(secnds)
da = dist(sc - mn, TAU)
db = dist(hr - mn, TAU)
dc = dist(sc - hr, TAU)
return (math.sqrt((da * da + db * db + dc * dc - square(da + db + dc)\
/ 3.0) / 2.0))
LC_HALAQIM_PER_HOUR = 1080
LX_HALAQIM = HOUR / LC_HALAQIM_PER_HOUR
LC_YEAR_PER_METONIC = 19
def date_easter(g_year):
century = floor(g_year / 100)
modmet = g_year % LC_YEAR_PER_METONIC
skipped_leap = century - floor(century / 4)
leap_years = floor(g_year / 4)
kk = floor((century + 8) / 25 - 1)
jj = floor((century - kk) / 3)
ii = (skipped_leap - jj + LC_YEAR_PER_METONIC * modmet + 15) % 30
if (28 < ii or (ii == 28 and 10 < modmet)):
ii -= 1
dow = (g_year + leap_years + ii + 2 - skipped_leap) % 7
return int(ii - dow + 28)
def date_rosh_hashanah(g_year):
aa = (12 * g_year + 12) % LC_YEAR_PER_METONIC
am = round(MOON_MONTH / LX_HALAQIM) * aa - 1565.0 * g_year
dos = floor(g_year / 100) - floor(g_year / 400) - 2 + (g_year % 4) /\
4.0 + (am - 445405) / (LC_YEAR_PER_METONIC * DAY / LX_HALAQIM)
day_of_september = floor(dos)
parts = (dos - day_of_september) * DAY / LX_HALAQIM
doww = ymd2dow(g_year, 9, day_of_september)
if (doww == 0 or doww == 3 or doww == 5):
day_of_september += 1
elif (doww == 1 and 11 < aa and 23269 <= parts):
day_of_september += 1
elif (doww == 2 and 6 < aa and 16404 <= parts):
day_of_september += 2
return (day_of_september - 0.25)
def jewish2jdx(hebyear):
hymod = (hebyear - 1) % LC_YEAR_PER_METONIC
months_el = (235 * floor((hebyear - 1) / LC_YEAR_PER_METONIC) + 12 *\
hymod + floor((7 * hymod + 1) / LC_YEAR_PER_METONIC))
halaqims_el = 204 + (793 * (months_el % LC_HALAQIM_PER_HOUR))
hour_el = (5 + (12 * months_el) + 793 * floor(months_el /\
LC_HALAQIM_PER_HOUR) + floor(halaqims_el / LC_HALAQIM_PER_HOUR))
days_left = floor(hour_el / (DAY / HOUR)) + 1 + 29 * months_el
alt_days = days_left + 347996
alt_dow = (alt_days % iround(WEEK / DAY))
hq_left = (halaqims_el % LC_HALAQIM_PER_HOUR)
hq_left += DAY * frac(hour_el * HOUR / DAY) / LX_HALAQIM
if (19440 <= hq_left):
if (0 == alt_dow or 2 == alt_dow or 4 == alt_dow):
alt_days += 2
else:
alt_days += 1
elif (0 == alt_dow):
if (9924 <= hq_left):
if (not isjewishleap(hebyear)):
alt_days += 2
elif (6 == alt_dow):
if (16789 <= hq_left and isjewishleap(hebyear - 1)):
alt_days += 1
elif (1 == alt_dow or 3 == alt_dow or 5 == alt_dow):
alt_days += 1
return (alt_days + 0.25)
def isjewishleap(hebyear):
return ((7 * hebyear + 1) % LC_YEAR_PER_METONIC < 7)
def date_pesach(g_year):
rh = date_rosh_hashanah(g_year)
return (rh + 21)
def g2jewish(g_year):
return int(g_year + 3761)
def jewish2g(hebyear):
return int(hebyear - 3760)
def jewish_months_in_year(hebyear):
if (isjewishleap(hebyear)):
miy = 13
else:
miy = 12
return int(miy)
def jewish_yearlength(hebyear):
g_year = jewish2g(hebyear - 1)
retvalu = (floor(JYEAR / JDAY) + (date_rosh_hashanah(g_year + 1) -\
date_rosh_hashanah(g_year)))
if (isleapyear(g_year + 1)):
retvalu += 1
return int(retvalu)
def jewish2jd(hebyear):
gregyear = jewish2g(hebyear - 1)
return (ymd2jd(gregyear, 9, date_rosh_hashanah(gregyear)))
def isjewish8short(hebyear):
remten = jewish_yearlength(hebyear) % 10
return (remten != 5)
def isjewish9short(hebyear):
remten = jewish_yearlength(hebyear) % 10
return (remten == 3)
def jewish_monthlength(hebyear, hebmonth):
retvalu = 30
if (hebmonth < 1 or 13 < hebmonth):
retvalu = 0
elif (hebmonth < 8):
if (iseven(hebmonth)):
retvalu = 29
elif (hebmonth == 8):
if (isjewish8short(hebyear)):
retvalu = 29
elif (hebmonth == 9):
if (isjewish9short(hebyear)):
retvalu = 29
elif (hebmonth == 10):
retvalu = 29
elif (hebmonth == 11):
retvalu = 30
elif (hebmonth == 12):
if (not isjewishleap(hebyear)):
retvalu = 29
elif (hebmonth == 13 and isjewishleap(hebyear)):
retvalu = 29
else:
retvalu = 0
return int(retvalu)
def jewish_monthbegin(hebyear, hmonth):
g_year = jewish2g(hebyear - 1)
g_month = 9
if (hmonth < JEWISH_FIRST_MONTH):
g_year += 1
gdate = date_rosh_hashanah(g_year)
for hm in range(JEWISH_FIRST_MONTH - 1, hmonth - 1, -1):
g_month -= 1
gdate += (days_in_month(g_year, g_month) -\
jewish_monthlength(hebyear, hm))
else:
gdate = date_rosh_hashanah(g_year)
for hm in range(JEWISH_FIRST_MONTH, hmonth + 0, 1):
gdate -= (days_in_month(g_year, g_month) -\
jewish_monthlength(hebyear, hm))
g_month += 1
if (MONTHS_IN_YEAR < g_month):
g_month = 1
g_year += 1
return int(gdate)
def jewishymd2jd(hebyear, hebmonth, hebday):
moninyear = jewish_months_in_year(hebyear)
if (1 <= hebmonth and hebmonth <= moninyear):
jds = jewish2jd(hebyear)
hfirst = JEWISH_FIRST_MONTH
hmon = JEWISH_FIRST_MONTH
while (hmon != hebmonth):
jds += jewish_monthlength(hebyear, hmon)
hmon += 1
if (moninyear < hmon):
hmon = 1
elif (hmon == hfirst):
hebyear += 1
moninyear = jewish_months_in_year(hebyear)
else:
jds = 0
return (jds + hebday - 1.0)
def amean(xa, xb):
return ((xa + xb) / 2.0)
def amean1(xa):
return ((xa + 1.0) / 2.0)
def lmean(xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
diffy = xa - xb
if (0.0001 < math.fabs(diffy)):
retvalu = diffy / math.log(xa / xb)
else:
retvalu = diffy / ln1p(diffy / xb)
return (retvalu)
def lmean1(xa):
return (lmean(1.0, xa))
def pmean(pp, xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
elif (iszero(pp)):
retvalu = math.sqrt(xa * xb)
else:
retvalu = math.pow((math.pow(xa, pp) + math.pow(xb, pp)) / 2.0, 1.0\
/ pp)
return (retvalu)
def gmean(xa, xb):
if (xa < 0.0 or xb < 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
retvalu = math.sqrt(xa * xb)
return (retvalu)
def gmean1(xa):
return (gmean(1.0, xa))
def hmean(xa, xb):
if (xa < 0.0 or xb < 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
retvalu = 2.0 * xa * xb / (xa + xb)
return (retvalu)
def hmean1(xa):
return (hmean(1.0, xa))
def qmean(xa, xb):
if (xa < 0.0 or xb < 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
retvalu = math.sqrt((xa * xa + xb * xb) / 2.0)
return (retvalu)
def qmean1(xa):
return (qmean(1.0, xa))
def heronianmean(xa, xb):
if (xa < 0.0 or xb < 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
retvalu = (xa + xb + math.sqrt(xa * xb)) / 3.0
return (retvalu)
def heronianmean1(xa):
return (heronianmean(1.0, xa))
def agmean(xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
cdifff = math.fabs(xa - xb)
ii = 0
while True:
pdifff = cdifff
xtmp = math.sqrt(xa * xb)
xa = (xa + xb) / 2.0
xb = xtmp
cdifff = xa - xb
if (iswithin(xa, xb, 10.0 * DBLEPS) or pdifff < cdifff):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xtmp
return (retvalu)
def agmean1(xa):
return (agmean(1.0, xa))
def ahmean(xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
cdifff = math.fabs(xa - xb)
ii = 0
while True:
pdifff = cdifff
xtmp = 2.0 * xa * xb / (xa + xb)
xa = (xa + xb) / 2.0
xb = xtmp
cdifff = xa - xb
if (iswithin(xa, xb, 10.0 * DBLEPS) or pdifff < cdifff):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xtmp
return (retvalu)
def ahmean1(xa):
return (ahmean(1.0, xa))
def almean(xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
cdifff = math.fabs(xa - xb)
ii = 0
while True:
pdifff = cdifff
xtmp = lmean(xa, xb)
xa = (xa + xb) / 2.0
xb = xtmp
cdifff = xa - xb
if (iswithin(xa, xb, 10.0 * DBLEPS) or pdifff < cdifff):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xtmp
return (retvalu)
def almean1(xa):
return (almean(1.0, xa))
def aqmean(xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
cdifff = math.fabs(xa - xb)
ii = 0
while True:
pdifff = cdifff
xtmp = (xa + xb) / 2.0
xa = qmean(xa, xb)
xb = xtmp
cdifff = xa - xb
if (iswithin(xa, xb, 10.0 * DBLEPS) or pdifff < cdifff):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xtmp
return (retvalu)
def aqmean1(xa):
return (aqmean(1.0, xa))
def ghmean(xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
cdifff = math.fabs(xa - xb)
ii = 0
while True:
pdifff = cdifff
xtmp = 2.0 * xa * xb / (xa + xb)
xa = math.sqrt(xa * xb)
xb = xtmp
cdifff = xa - xb
if (iswithin(xa, xb, 10.0 * DBLEPS) or pdifff < cdifff):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xtmp
return (retvalu)
def ghmean1(xa):
return (ghmean(1.0, xa))
def glmean(xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
cdifff = math.fabs(xa - xb)
ii = 0
while True:
pdifff = cdifff
xtmp = math.sqrt(xa * xb)
xa = lmean(xa, xb)
xb = xtmp
cdifff = xa - xb
if (iswithin(xa, xb, 10.0 * DBLEPS) or pdifff < cdifff):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xtmp
return (retvalu)
def glmean1(xa):
return (glmean(1.0, xa))
def gqmean(xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
cdifff = math.fabs(xa - xb)
ii = 0
while True:
pdifff = cdifff
xtmp = math.sqrt(xa * xb)
xa = qmean(xa, xb)
xb = xtmp
cdifff = xa - xb
if (iswithin(xa, xb, 10.0 * DBLEPS) or pdifff < cdifff):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xtmp
return (retvalu)
def gqmean1(xa):
return (gqmean(1.0, xa))
def hlmean(xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
cdifff = math.fabs(xa - xb)
ii = 0
while True:
pdifff = cdifff
xtmp = 2.0 * xa * xb / (xa + xb)
xa = lmean(xa, xb)
xb = xtmp
cdifff = xa - xb
if (iswithin(xa, xb, 10.0 * DBLEPS) or pdifff < cdifff):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xtmp
return (retvalu)
def hlmean1(xa):
return (hlmean(1.0, xa))
def hqmean(xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
cdifff = math.fabs(xa - xb)
ii = 0
while True:
pdifff = cdifff
xtmp = 2.0 * xa * xb / (xa + xb)
xa = qmean(xa, xb)
xb = xtmp
cdifff = xa - xb
if (iswithin(xa, xb, 10.0 * DBLEPS) or pdifff < cdifff):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xtmp
return (retvalu)
def hqmean1(xa):
return (hqmean(1.0, xa))
def lqmean(xa, xb):
if (xa <= 0.0 or xb <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb)):
retvalu = xa
else:
cdifff = math.fabs(xa - xb)
ii = 0
while True:
pdifff = cdifff
xtmp = lmean(xa, xb)
xa = qmean(xa, xb)
xb = xtmp
cdifff = xa - xb
if (iswithin(xa, xb, 10.0 * DBLEPS) or pdifff < cdifff):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xtmp
return (retvalu)
def lqmean1(xa):
return (lqmean(1.0, xa))
def agmean__1(xa, xb):
xsgn = 1.0
ii = 0
while True:
xtmp = xa
xa = (xa + xb) / 2.0
xb = math.sqrt(math.fabs(xtmp * xb)) * sign(xa)
if (iswithin(xa, xb, 10.0 * DBLEPS)):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xsgn * xtmp
return (retvalu)
def agcmean(xa_arr_pc, xb_arr_pc, ret_arr_p):
gg_arr = [0 for ii in range(2)]
aa_arr = [0 for ii in range(2)]
tt_arr = [0 for ii in range(2)]
pr_arr = [0 for ii in range(2)]
gg_arr[0] = xa_arr_pc[0]
gg_arr[1] = xa_arr_pc[1]
aa_arr[0] = xb_arr_pc[0]
aa_arr[1] = xb_arr_pc[1]
while True:
tt_arr[0] = (aa_arr[0] + gg_arr[0]) / 2
tt_arr[1] = (aa_arr[1] + gg_arr[1]) / 2
pr_arr[0] = aa_arr[0] * gg_arr[0] - aa_arr[1] * gg_arr[1]
pr_arr[1] = aa_arr[1] * gg_arr[0] + aa_arr[0] * gg_arr[1]
pr_len = math.sqrt(hypot(pr_arr[0], pr_arr[1]))
pr_theta = math.atan2(pr_arr[1], pr_arr[0]) / 2.0
gg_arr[0] = pr_len * math.cos(pr_theta)
gg_arr[1] = pr_len * math.sin(pr_theta)
aa_arr[0] = tt_arr[0]
aa_arr[1] = tt_arr[1]
if (aa_arr[0] * gg_arr[0] + aa_arr[1] * gg_arr[1] < 0.0):
gg_arr[0] = -gg_arr[0]
gg_arr[1] = -gg_arr[1]
if (iseq(gg_arr[0], aa_arr[0]) and iseq(gg_arr[1], aa_arr[1])):
break# loop AWAIT
ret_arr_p[0] = gg_arr[0]
ret_arr_p[1] = gg_arr[1]
return (hypot(gg_arr[0], gg_arr[1]))
def aghmean(xa, xb, xc):
if (xa <= 0.0 or xb <= 0.0 or xc <= 0.0):
retvalu = 0.0
elif (iseq(xa, xb) and iseq(xa, xc)):
retvalu = xa
else:
ii = 0
while True:
ta = xa
tb = xb
tc = xc
xa = (ta + tb + tc) / 3.0
xb = cuberoot(ta * tb * tc)
xc = 3.0 / (1.0 / ta + 1.0 / tb + 1.0 / tc)
if (iswithin(xa, xc, 10.0 * DBLEPS)):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = xb
return (retvalu)
def rms(xa, xb):
return (math.sqrt((xa * xa + xb * xb) / 2.0))
def agmeaninva(aa, gg):
if (gg < aa):
new_aa = aa + math.sqrt(aa * aa - gg * gg)
else:
new_aa = gg + math.sqrt(gg * gg - aa * aa)
return (new_aa)
def agmeaninvg(aa, gg):
if (gg < aa):
new_gg = gg * gg / aa
else:
new_gg = aa * aa / gg
return (new_gg)
def agmean1inv(yy):
if (yy <= 0.0):
scvx_xx = 0.0
elif (yy < 0.0022):
scvx_xx = 1.0 / DBLMAX
else:
if (yy <= 0.5):
x_init = 4.0 * math.exp(PI / (-2.0 * yy))
elif (yy < 2.1):
cc = yy - 1.0
x_init = ((((((((-0.09765625) * cc + 0.12890625) * cc + 0.1875)\
* cc + 0.1875) * cc - 0.25) * cc + 0.5) * cc + 2.0) *\
cc + 1.0)
else:
cc = -(PI / 2.0)
x_init = yy * wm(cc / (4.0 * yy)) / cc
if (yy < 0.06):
dx = x_init * 0.1
else:
dx = x_init * 0.5
scvx_dx = dx
scvx_xx = x_init
scvx_yy = yy - agmean1(scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = yy - agmean1(scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def ghmean1inv(yy):
if (yy <= 0.0):
scvx_xx = 0.0
else:
if (yy < 0.073):
x_init = 0.352 * yy
else:
x_init = (math.exp(PI * yy / 2.0) - math.exp(-yy * yy * 0.2)) / 4.0
scvx_dx = 0.3
scvx_xx = x_init
scvx_yy = yy - ghmean1(scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = yy - ghmean1(scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def contraharmonic(nn, val_arr_pc):
numer = 0.0
denom = 0.0
for ii in range(0, nn + 0, 1):
denom += val_arr_pc[ii] * val_arr_pc[ii]
numer += val_arr_pc[ii]
return (denom / numer)
LC_KNUTH_MAX = 1073741823
LC_KNUTH_QUALITY_CNT = 1009
LC_KNUTH_KK_CNT = 100
LC_KNUTH_LL = 37
LC_KNUTH_TT = 70
LC_KNUTH_ARRAY_CNT = 1100
lv_ranz_ind = -3
lv_ranz_magic = 0.0
lv_ranz_arr = [0 for ii in range(LC_KNUTH_QUALITY_CNT)]
lv_ran_a_arr = [0 for ii in range(LC_KNUTH_ARRAY_CNT)]
lv_ran_x_arr = [0 for ii in range(LC_KNUTH_KK_CNT)]
def lf_ran_cycle(nn):
global lv_ran_x_arr
global lv_ran_a_arr
aa = 0
while (aa < LC_KNUTH_KK_CNT):
lv_ran_a_arr[aa] = lv_ran_x_arr[aa]
aa += 1
bb = 0
cc = (LC_KNUTH_KK_CNT - LC_KNUTH_LL)
while (aa < nn):
mody = lv_ran_a_arr[bb] - lv_ran_a_arr[cc]
lv_ran_a_arr[aa] = (LC_KNUTH_MAX & mody)
aa += 1
bb += 1
cc += 1
aa = 0
while (aa < LC_KNUTH_LL):
mody = lv_ran_a_arr[bb] - lv_ran_a_arr[cc]
lv_ran_x_arr[aa] = (LC_KNUTH_MAX & mody)
aa += 1
bb += 1
cc += 1
cc = 0
while (aa < LC_KNUTH_KK_CNT):
mody = lv_ran_a_arr[bb] - lv_ran_x_arr[cc]
lv_ran_x_arr[aa] = (LC_KNUTH_MAX & mody)
aa += 1
bb += 1
cc += 1
return int(bb)
def lf_fill_ranz():
global lv_ranz_magic
global lv_ranz_ind
global lv_ranz_arr
global lv_ran_a_arr
lf_ran_cycle(LC_KNUTH_QUALITY_CNT)
for jj in range(0, LC_KNUTH_QUALITY_CNT + 0, 1):
lv_ranz_arr[jj] = lv_ran_a_arr[jj]
lv_ranz_arr[LC_KNUTH_KK_CNT] = -1
lv_ranz_ind = 0
lv_ranz_magic = magicset()
return int(lv_ranz_arr[0])
def lf_next_ranz():
global lv_ranz_magic
global lv_ranz_ind
global lv_ranz_arr
if (not ismagic(lv_ranz_magic)):
rand_init(timee())
elif (lv_ranz_arr[lv_ranz_ind] < 0):
lf_fill_ranz()
lv_ranz_ind += 1
return int(lv_ranz_arr[lv_ranz_ind - 1])
def rand_init_array(seed_size, seed_arr_pc):
global lv_ran_x_arr
rnd_arr = [0 for ii in range(2 * LC_KNUTH_KK_CNT)]
rndss = ((seed_arr_pc[0] + 2) & (LC_KNUTH_MAX - 1))
for jj in range(0, LC_KNUTH_KK_CNT + 0, 1):
rnd_arr[jj] = rndss
rndss = (rndss << 1)
if (LC_KNUTH_MAX < rndss):
rndss -= (LC_KNUTH_MAX - 1)
rndff = 0
seed_ind = 0
bitmask = 0
for jj in range(0, LC_KNUTH_KK_CNT + 0, 1):
if (bitmask <= 1):
seed_ind += 1
if (seed_size <= seed_ind):
break
rndff = seed_arr_pc[seed_ind]
bitmask = (1 << 30)
if ((rndff & bitmask) != 0):
rnd_arr[jj] = (bitmask ^ (rnd_arr[jj]))
bitmask = (bitmask >> 1)
rnd_arr[1] += 1
rndss = (seed_arr_pc[0] & LC_KNUTH_MAX)
tt = LC_KNUTH_TT - 1
while (0 < tt):
for jj in range(LC_KNUTH_KK_CNT - 1, 0, -1):
rnd_arr[jj + jj] = rnd_arr[jj]
rnd_arr[jj + jj - 1] = 0
jj = LC_KNUTH_KK_CNT + LC_KNUTH_KK_CNT - 2
dd = LC_KNUTH_KK_CNT + LC_KNUTH_LL - 2
kk = LC_KNUTH_KK_CNT - 2
while (0 <= kk):
rndx = rnd_arr[dd] - rnd_arr[jj]
rnd_arr[dd] = (rndx & LC_KNUTH_MAX)
rndx = rnd_arr[kk] - rnd_arr[jj]
rnd_arr[kk] = (rndx & LC_KNUTH_MAX)
dd -= 1
kk -= 1
jj -= 1
if (isodd(rndss)):
for jj in range(LC_KNUTH_KK_CNT, 0, -1):
rnd_arr[jj] = rnd_arr[jj - 1]
rnd_arr[0] = rnd_arr[LC_KNUTH_KK_CNT]
jj = rnd_arr[LC_KNUTH_LL] - rnd_arr[0]
rnd_arr[LC_KNUTH_LL] = (LC_KNUTH_MAX & jj)
rndss = (rndss >> 1)
elif (rndss == 0):
tt -= 1
else:
rndss = (rndss >> 1)
kk = (LC_KNUTH_KK_CNT - LC_KNUTH_LL)
jj = 0
while (jj < LC_KNUTH_LL):
lv_ran_x_arr[kk] = rnd_arr[jj]
kk += 1
jj += 1
kk = 0
while (jj < LC_KNUTH_KK_CNT):
lv_ran_x_arr[kk] = rnd_arr[jj]
kk += 1
jj += 1
for jj in range(0, 10, 1):
lf_ran_cycle(2 * LC_KNUTH_KK_CNT - 1)
lf_fill_ranz()
return 0
def rand_init(seed):
sd_arr = [0 for ii in range(2)]
sd_arr[0] = floor(seed)
sd_arr[1] = floor(frac(seed) * INTMAX)
rand_init_array(2, sd_arr)
return (seed)
def randl(nn):
max_allowed = LC_KNUTH_MAX - (LC_KNUTH_MAX % nn)
while True:
rndm = lf_next_ranz()
if (rndm < max_allowed):
break# loop AWAIT
retvalu = rndm % nn
return int(retvalu)
def randd():
return ((lf_next_ranz() + lf_next_ranz() / (LC_KNUTH_MAX + 1.0)) /\
(LC_KNUTH_MAX + 1.0))
def int_pdf(para_nn, xx):
if (xx < 0.0 or para_nn < xx or (not isint(xx))):
retvalu = 0.0
else:
ff = floor(para_nn)
if (isint(para_nn)):
if (xx < para_nn):
retvalu = 1.0 / para_nn
else:
retvalu = 0.0
else:
if (xx < ff):
retvalu = 1.0 / para_nn
else:
retvalu = 1.0 - ff / para_nn
return (retvalu)
def int_cdf(para_nn, xx):
if (xx <= 0.0):
retvalu = 0.0
elif (para_nn <= xx):
retvalu = 1.0
else:
ff = floor(para_nn)
if (xx < ff):
retvalu = (floor(xx) + 1) / para_nn
else:
retvalu = 1
return (retvalu)
def int_quantile(para_nn, probx):
if (probx <= 0.0):
retvalu = 0.0
elif (1.0 - frac(para_nn) / para_nn <= probx):
retvalu = math.ceil(para_nn - 1)
else:
retvalu = floor(para_nn * probx + 1)
return (retvalu)
def int_rand(para_nn):
if (para_nn <= 1):
retvalu = 0
else:
retvalu = floorl(randd() * para_nn)
return int(retvalu)
def normal_pdf(xx):
return (math.exp(-xx * xx / 2.0) / (math.sqrt(TAU)))
def normal_cdf(xx):
return (erf(xx / TWOSQRT) / 2.0 + 0.5)
def normal_cdf__1(xx):
if (xx <= -10.0):
retvalu = 0.0
elif (10.0 <= xx):
retvalu = 1.0
elif (iszero(xx)):
retvalu = 0.5
else:
sum_curr = 0.0
bb = 1.0 / xx
xx_sqr = xx * xx
ii = 0
while True:
bb *= xx_sqr / (2.0 * ii + 1.0)
sum_prev = sum_curr
sum_curr += bb
if (iseq(sum_prev, sum_curr)):
break# loop AWAIT
ii += 1
retvalu = (sum_curr * math.exp(-0.5 * (xx_sqr + math.log(TAU))) + 0.5)
return (retvalu)
def normal_quantile(probx):
return (TWOSQRT * erfinv(2.0 * probx - 1.0))
lv_rand_gau_magic = 0.0
lv_rand_gau_prev = 0.0
def normal_rand():
global lv_rand_gau_magic
global lv_rand_gau_prev
if (ismagic(lv_rand_gau_magic)):
lv_rand_gau_magic = magicnot()
retvalu = lv_rand_gau_prev
else:
while True:
uua = randd() - 0.5
uub = randd() - 0.5
ww = uua * uua + uub * uub
if (isbetweenx(ww, 0.0, 0.25)):
break# loop AWAIT
ww = math.sqrt(-2.0 * math.log(4.0 * ww) / ww)
lv_rand_gau_prev = uub * ww
lv_rand_gau_magic = magicset()
retvalu = uua * ww
return (retvalu)
def gau_pdf(xx):
return (normal_pdf(xx))
def gau_cdf(xx):
return (normal_cdf(xx))
def gau_quantile(probx):
return (normal_quantile(probx))
def gau_rand():
return (normal_rand())
def normal_quantile__1(probx):
p_low = 0.02425
if (probx <= 0.0):
retvalu = -(DBLMAX)
elif (1.0 <= probx):
retvalu = DBLMAX
elif (p_low <= probx and probx <= 1.0 - p_low):
qq = probx - 0.5
rr = qq * qq
numer = ((((((-3.96968302866538E+1) * rr + 2.20946098424521E+2) *\
rr - 2.75928510446969E+2) * rr + 1.38357751867269E+2) * rr\
- 3.06647980661472E+1) * rr + 2.50662827745924)
denom = ((((((-5.44760987982241E+1) * rr + 1.61585836858041E+2) *\
rr - 1.55698979859887E+2) * rr + 6.68013118877197E+1) * rr\
- 1.32806815528857E+1) * rr + 1.00000000000000)
retvalu = (qq * numer / denom)
else:
if (probx < p_low):
rr = math.sqrt(-2.0 * math.log(probx))
qq = 1.0
else:
rr = math.sqrt(-2.0 * math.log(1 - probx))
qq = -1.0
numer = ((((((-7.78489400243029E-3) * rr - 3.22396458041136E-1) *\
rr - 2.40075827716184) * rr - 2.54973253934373) * rr +\
4.37466414146497) * rr + 2.93816398269878)
denom = (((((7.78469570904146E-3) * rr + 3.22467129070040E-1) * rr\
+ 2.44513413714300) * rr + 3.75440866190742) * rr +\
1.00000000000000)
retvalu = qq * numer / denom
return (retvalu)
def uni_pdf(max_x, xxp):
if (max_x <= 0.0 or xxp <= 0.0 or max_x <= xxp):
retvalu = 0.0
else:
retvalu = 1.0 / max_x
return (retvalu)
def uni_cdf(max_x, xxp):
if (max_x <= 0.0 or xxp < 0.0):
retvalu = 0.0
elif (max_x < xxp):
retvalu = 1.0
else:
retvalu = xxp / max_x
return (retvalu)
def uni_quantile(max_x, probx):
if (probx < 0.0 or max_x <= 0.0):
retvalu = 0.0
elif (max_x < probx):
retvalu = 1.0
else:
retvalu = probx * max_x
return (retvalu)
def uni_rand(max_x):
return (uni_quantile(max_x, randd()))
def exp_pdf(para_scaling, xxp):
if (xxp < 0.0 or para_scaling <= 0.0):
retvalu = 0.0
else:
retvalu = para_scaling * math.exp(-para_scaling * xxp)
return (retvalu)
def exp_cdf(para_scaling, xxp):
if (xxp < 0.0 or para_scaling <= 0.0):
retvalu = 0.0
else:
retvalu = 1.0 - math.exp(-para_scaling * xxp)
return (retvalu)
def exp_quantile(para_scaling, probx):
if (probx <= 0.0 or para_scaling <= 0.0):
retvalu = 0.0
elif (1.0 <= probx):
retvalu = DBLMAX
else:
retvalu = -math.log(1.0 - probx) / para_scaling
return (retvalu)
def exp_rand(para_scaling):
return (- math.log(randd()) / para_scaling)
def poi_pdf(meanx, xxp):
if (xxp < 0.0 or meanx <= 0.0):
retvalu = 0.0
else:
kk = floor(xxp)
retvalu = math.pow(meanx, kk) * math.exp(-meanx) / factorial(kk)
return (retvalu)
def poi_cdf(meanx, xxp):
if (xxp <= 0.0 or meanx <= 0.0):
retvalu = 0.0
elif (1000.0 < xxp / meanx):
retvalu = 1
else:
term = math.exp(-meanx)
sum = term
kk = floorl(xxp)
for ii in range(1, kk + 1, 1):
term *= meanx / ii
sum += term
retvalu = sum
return (retvalu)
def poi_quantile(meanx, probx):
if (probx <= 0.0 or meanx <= 0.0):
retvalu = 0.0
elif (1.0 <= probx):
retvalu = DBLMAX
else:
prevsum = 0.0
term = math.exp(-meanx)
sum = term
ii = 0
while (sum <= probx):
ii += 1
term *= meanx / ii
prevsum = sum
sum += term
if (sum - probx < probx - prevsum):
retvalu = ii
else:
retvalu = ii - 1
return (retvalu)
def poi_rand(meanx):
prob = randd()
poi = math.exp(-meanx)
sum = poi
nn = 0
while (sum < prob):
nn += 1
poi *= meanx / nn
sum += poi
return int(nn)
def geo_pdf(prob, kk):
if (kk < 0 or prob < 0.0 or 1.0 <= prob):
retvalu = 0.0
else:
retvalu = math.pow(1.0 - prob, kk) * prob
return (retvalu)
def geo_cdf(prob, kk):
if (kk <= -1 or prob < 0.0):
retvalu = 0.0
elif (1.0 <= prob):
retvalu = 1.0
else:
retvalu = 1.0 - math.pow(1.0 - prob, kk + 1)
return (retvalu)
def geo_quantile(prob, probx):
if (probx <= 0.0 or 1.0 <= probx or prob <= 0.0 or 1.0 <= prob):
retvalu = 0.0
else:
retvalu = math.log(1.0 - probx) / math.log(1.0 - prob) - 1.0
return (retvalu)
def geo_rand(prob):
return int((floorl(math.log(randd()) / math.log(1.0 - prob))))
def cauchy_pdf(para_scaling, xx):
return (1.0 / (PI * para_scaling * (1.0 + (square(xx / para_scaling)))))
def cauchy_cdf(para_scaling, xx):
return (taninv(xx / para_scaling) / PI + 0.5)
def cauchy_quantile(para_scaling, probx):
return (para_scaling * math.tan((probx - 0.5) * PI))
def cauchy_rand(para_scaling):
return (cauchy_quantile(para_scaling, randd()))
def logistic_pdf(ss, xx):
if (ss <= 0.0):
retvalu = 0.0
else:
exs = math.exp(-xx / ss)
retvalu = exs / (ss * math.pow(1.0 + exs, 2.0))
return (retvalu)
def logistic_cdf(ss, xx):
if (ss <= 0.0):
retvalu = 0.0
else:
retvalu = 1.0 / (1.0 + math.exp(-xx / ss))
return (retvalu)
def logistic_quantile(ss, probx):
if (probx <= 0.0 or ss <= 0.0):
retvalu = 0.0
elif (1.0 <= probx):
retvalu = 1.0
else:
retvalu = -ss * math.log(1.0 / probx - 1.0)
return (retvalu)
def logistic_rand(ss):
return (- ss * math.log(1.0 / randd() - 1.0))
def tri_pdf(pp, xxp):
if (pp < 0.0 or 1.0 < pp):
retvalu = 0.0
else:
if (xxp < 0.0 or 1.0 < xxp):
retvalu = 0.0
elif (xxp < pp):
retvalu = divi(2.0 * xxp, pp, 2.0)
else:
retvalu = divi(2.0 * (1.0 - xxp), 1.0 - pp, 2.0)
return (retvalu)
def tri_cdf(pp, xxp):
if (pp < 0.0 or 1.0 < pp):
retvalu = 0.0
else:
if (xxp <= 0.0):
retvalu = 0.0
elif (xxp < pp):
retvalu = xxp * xxp / pp
elif (xxp < 1.0):
retvalu = 1.0 - square(1.0 - xxp) / (1.0 - pp)
else:
retvalu = 1.0
return (retvalu)
def tri_quantile(pp, probx):
if (pp < 0.0 or 1.0 < pp):
retvalu = 0.0
else:
if (probx <= 0.0):
retvalu = 0.0
elif (probx < pp):
retvalu = math.sqrt(probx * pp)
elif (probx < 1.0):
retvalu = 1.0 - math.sqrt((1.0 - probx) * (1.0 - pp))
else:
retvalu = 1.0
return (retvalu)
def tri_rand(pp):
xxp = randd()
yy = randd()
if (xxp < pp):
if (2.0 * xxp < pp * yy):
xxp = pp - xxp
else:
if ((pp - 1.0) * yy < 2.0 * (xxp - 1.0)):
xxp = (pp + 1.0) - xxp
return (xxp)
def trap_pdf(prob_a, prob_b, xx):
if (xx < 0.0 or 1.0 < xx or prob_a < 0.0 or prob_b < prob_a or 1.0 <\
prob_b):
retvalu = 0.0
else:
if (xx < prob_a):
retvalu = xx / prob_a
elif (xx <= prob_b):
retvalu = 1.0
else:
retvalu = (1.0 - xx) / (1.0 - prob_b)
return (retvalu * 2.0 / (1.0 + prob_b - prob_a))
def trap_cdf(prob_a, prob_b, xx):
if (prob_a < 0.0 or prob_b < prob_a or 1.0 < prob_b):
retvalu = 0.0
elif (xx <= 0.0):
retvalu = 0.0
elif (1.0 <= xx):
retvalu = 1.0
else:
ff = 2.0 / (1.0 + prob_b - prob_a)
if (xx < prob_a):
retvalu = ff * xx * xx / (2.0 * prob_a)
elif (xx < prob_b):
retvalu = ff * (xx - prob_a / 2.0)
else:
retvalu = 1.0 - ff * square(1.0 - xx) / (2.0 * (1.0 - prob_b))
return (retvalu)
def trap_quantile(prob_a, prob_b, xx):
if (prob_a < 0.0 or prob_b < prob_a or 1.0 < prob_b):
retvalu = 0.0
elif (xx <= 0.0):
retvalu = 0.0
elif (1.0 <= xx):
retvalu = 1.0
else:
ff = 2.0 / (1.0 + prob_b - prob_a)
if (xx < prob_a * ff / 2.0):
retvalu = math.sqrt((2.0 * prob_a * xx) / ff)
elif (xx < 1.0 - ff * (1.0 - prob_b) / 2.0):
retvalu = xx / ff + prob_a / 2.0
else:
retvalu = 1.0 - math.sqrt(2.0 * (1.0 - prob_b) * (1.0 - xx) / ff)
return (retvalu)
def trap_rand(prob_a, prob_b):
retvalu = -1
while True:
xx = randd()
if (xx < prob_a):
if (randd() * prob_a < xx):
retvalu = xx
elif (xx <= prob_b):
retvalu = xx
else:
if (randd() * (1.0 - prob_b) < (1.0 - xx)):
retvalu = xx
if (0.0 <= retvalu):
break# loop AWAIT
return (retvalu)
def pareto_pdf(para_shape, para_scaling, xx):
return (para_shape * math.pow(para_scaling / xx, para_shape) / xx)
def pareto_cdf(para_shape, para_scaling, xx):
return (1.0 - math.pow(para_scaling / xx, para_shape))
def pareto_quantile(para_shape, para_scaling, probx):
return (para_scaling / math.pow(1.0 - probx, 1.0 / para_shape))
def pareto_rand(para_shape, para_scaling):
return (para_scaling / math.pow(randd(), 1.0 / para_shape))
def gompertz_pdf(para_shape, para_scaling, xx):
return (math.exp(para_scaling * xx + para_shape * (1 -\
math.exp(para_scaling * xx))) * para_scaling * para_shape)
def gompertz_cdf(para_shape, para_scaling, xx):
return (1.0 - math.exp(para_shape * (1.0 - math.exp(para_scaling * xx))))
def gompertz_quantile(para_shape, para_scaling, probx):
return (math.log(1 - math.log(1.0 - probx) / para_shape) / para_scaling)
def gompertz_rand(para_shape, para_scaling):
return (gompertz_quantile(para_shape, para_scaling, randd()))
def zipf_pdf(ss, max_kk, kk):
if (kk <= 0.0 or max_kk < kk):
retvalu = 0.0
else:
retvalu = 1.0 / (math.pow(kk, ss) * hnm(max_kk, ss))
return (retvalu)
def zipf_cdf(ss, max_kk, kk):
if (kk <= 0.0):
retvalu = 0.0
elif (max_kk < kk):
retvalu = 1.0
else:
retvalu = hnm(kk, ss) / hnm(max_kk, ss)
return (retvalu)
def zipf_quantile(ss, max_kk, probx):
target = probx * hnm(max_kk, ss)
summ = 0.0
ii = 1
while True:
summ += 1.0 / math.pow(ii, ss)
if (target <= summ):
break# loop AWAIT
ii += 1
return int(ii)
def zipf_rand(ss, max_kk):
return int((zipf_quantile(ss, max_kk, randd())))
def beta_pdf(para_shape_a, para_shape_b, xx):
return (math.pow(xx, para_shape_a - 1.0) * math.pow((1.0 - xx),\
para_shape_b - 1.0) / beta(para_shape_a, para_shape_b))
def beta_cdf(para_shape_a, para_shape_b, xx):
return (betainc(para_shape_a, para_shape_b, xx))
def beta_quantile(para_shape_a, para_shape_b, probx):
if (probx <= 0.0):
retvalu = 0.0
elif (1.0 <= probx):
retvalu = 1.0
else:
scvx_dx = 0.50
scvx_xx = 0.25
scvx_yy = probx - beta_cdf(para_shape_a, para_shape_b, scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = probx - beta_cdf(para_shape_a, para_shape_b, scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
retvalu = scvx_xx
return (retvalu)
def beta_rand(para_shape_a, para_shape_b):
return (beta_quantile(para_shape_a, para_shape_b, randd()))
def gamma_pdf(para_shape, xxp):
if (xxp <= 0.0):
retvalu = 0.0
else:
retvalu = math.exp(math.log(xxp) * (para_shape - 1.0) - xxp) /\
tgamma(para_shape)
return (retvalu)
def gamma_cdf(para_shape, xxp):
if (xxp <= 0.0 or para_shape <= 0.0):
retvalu = 0.0
elif (isint(para_shape)):
sum = 1.0
rr = 1.0
for ii in range(1, para_shape + 0, 1):
rr *= xxp / ii
sum += rr
retvalu = 1.0 - math.exp(-xxp) * sum
else:
retvalu = rligamma(para_shape, xxp)
return (retvalu)
def gamma_rand(para_shape):
i_shape = floor(para_shape)
rval = 1.0
if (para_shape < 5):
for jj in range(1, i_shape + 1, 1):
rval *= randd()
rval = -math.log(rval)
f_shape = para_shape - i_shape
if (0.00001 < f_shape):
pp = E / (f_shape + E)
while True:
vv = math.log(randd())
if (randd() < pp):
xx = math.exp(vv / f_shape)
qq = math.exp(-xx)
else:
xx = 1.0 - vv
qq = math.exp(math.log(xx) * (f_shape - 1))
if (randd() < qq):
break# loop AWAIT
rval += xx
else:
ee = para_shape - 1.0
gg = math.sqrt(para_shape + ee)
yy = 0.0
ff = 0.0
while (rval <= 0.0 or (1.0 + yy * yy) * math.exp(ee * math.log(rval\
/ ee) - ff) < randd()):
xx = PI * randd()
yy = math.sin(xx) / math.cos(xx)
ff = gg * yy
rval = ff + ee
return (rval)
def chisqr_pdf(df, xxp):
if (xxp <= 0.0):
retvalu = 0.0
else:
retvalu = math.exp((math.log(xxp / 2.0) * df - xxp) / 2.0) / (xxp *\
tgamma(df / 2.0))
return (retvalu)
def chisqr_cdf(df, xxp):
if (xxp <= 0.0):
retvalu = 0.0
else:
retvalu = (1.0 - ruigamma(df / 2.0, xxp / 2.0))
return (retvalu)
def chisqr_rand(df):
sum = 0.0
for jj in range(1, df + 1, 1):
vv = gau_rand()
sum += vv * vv
if (not isint(df)):
sum += gamma_rand(frac(df) / 2.0) * 2.0
return (sum)
def binomial_pdf(prob_a, success, trial):
if (success < 0 or trial < success):
retvalu = 0.0
else:
retvalu = comb(trial, success) * math.pow(prob_a, success) *\
math.pow(1.0 - prob_a, trial - success)
return (retvalu)
def binomial_cdf(prob_a, success, trial):
if (prob_a <= 0.0 or success < 0):
lsum = 0.0
elif (1.0 <= prob_a or trial <= success):
lsum = 1.0
else:
if (trial <= 2 * success):
ss = trial - success - 1
prob_a = 1.0 - prob_a
else:
ss = success
sfactor = math.pow(1.0 - prob_a, trial)
mu = prob_a / (1.0 - prob_a)
lsum = 0.0
for kk in range(0, ss + 1, 1):
lsum += sfactor
sfactor *= (mu * (trial - kk)) / (kk + 1.0)
if (ss != success):
lsum = 1.0 - lsum
return (lsum)
def binomial_rand(prob_a, rr):
successes = 0.0
while (0 < rr):
if (randd() < prob_a):
successes += 1
rr -= 1
return (successes)
def benford_pdf(max_kk, kk):
if (kk <= 0.0 or max_kk <= kk):
retvalu = 0.0
else:
retvalu = math.log(1.0 + 1.0 / kk) / math.log(max_kk)
return (retvalu)
def benford_cdf(max_kk, kk):
if (kk <= 0.0):
retvalu = 0.0
elif (max_kk <= kk):
retvalu = 1.0
else:
retvalu = math.log(kk + 1.0) / math.log(max_kk)
return (retvalu)
def benford_rand(max_kk):
target = randd()
summ = 0.0
ii = 1
while True:
summ += math.log(1.0 + 1.0 / ii) / math.log(max_kk)
if (target <= summ):
break# loop AWAIT
ii += 1
return int(ii)
def nbd_pdf(prob_a, rsuccesses, kfailures):
return (comb(rsuccesses + kfailures - 1, kfailures) * math.pow(prob_a,\
rsuccesses) * math.pow(1.0 - prob_a, kfailures))
def nbd_cdf(prob_a, rsuccesses, kfailures):
return (1.0 - betainc(kfailures + 1, rsuccesses, 1.0 - prob_a))
def nbd_rand(prob_a, rsuccesses):
rr = rsuccesses
failures = 0
while (0 < rr):
if (randd() <= prob_a):
rr -= 1
else:
failures += 1
return int(failures)
def polya_pdf(prob_a, rsuccesses, kfailures):
return (combx(rsuccesses + kfailures - 1, kfailures) * math.pow(1.0 -\
prob_a, kfailures) * math.pow(prob_a, rsuccesses))
def polya_cdf(prob_a, rsuccesses, kfailures):
return (1.0 - betainc(kfailures + 1, rsuccesses, 1.0 - prob_a))
def polya_rand(tt, probx):
nn = 0
ff = tt - 1
qq = math.exp(tt * math.log(probx))
rr = qq
uu = randd()
while (rr <= uu):
nn += 1
ff += 1
qq *= (1.0 - probx) * ff / nn
rr += qq
return (nn)
def zeta_pdf(ss, ixxp):
if (ixxp <= 0.0):
retvalu = 0.0
else:
retvalu = 1.0 / (zeta(ss) * math.pow(ixxp, ss))
return (retvalu)
def zeta_cdf(ss, ixxp):
if (ixxp <= 0.0):
retvalu = 0.0
else:
retvalu = hnm(ixxp, ss) / zeta(ss)
return (retvalu)
def ks_cdf(para_nn, xx):
if (para_nn <= 0 or xx <= 0.0):
retvalu = 0.0
else:
if (30 < para_nn):
tt = xx
two_tt_sqr = 2.0 * tt * tt
sum = math.exp(-two_tt_sqr) * (1.0 - 2.0 * tt / (3.0 *\
math.sqrt(para_nn)) - two_tt_sqr * (two_tt_sqr / 9.0 -\
1.0 / 3.0) / para_nn)
retvalu = 1.0 - sum
else:
tt = xx * math.sqrt(para_nn)
sum = 0.0
kk = para_nn
while (tt < kk):
sum += comb(para_nn, kk) * math.pow(kk - tt, kk) *\
math.pow(tt + para_nn - kk, para_nn - kk - 1)
kk -= 1
retvalu = 1.0 - sum * tt / math.pow(para_nn, para_nn)
return (retvalu)
def ks_a_cdf(xx):
if (xx < 0.0001):
retvalu = 0.0
else:
sum = 0.0
vv = -square(PI / xx) / 8.0
kk = 1
while True:
sum_prev = sum
sum += math.exp(vv * kk * kk)
if (iseq(sum, sum_prev)):
break# loop AWAIT
kk += 2
retvalu = sum * math.sqrt(TAU) / xx
return (retvalu)
def ks_b_cdf(para_nn, xx):
if (xx < 0.0001 or para_nn <= 0):
retvalu = 0.0
else:
nxx = xx + (2.0 * math.sqrt(para_nn) + 3.0 * xx - 3.0) / (12.0 *\
para_nn)
retvalu = ks_a_cdf(nxx)
return (retvalu)
def ks_quantile(para_nn, probx):
if (not isbetween(probx, 0.0, 1.0)):
scvx_xx = 0.0
else:
scvx_dx = 0.5
scvx_xx = 0.25
scvx_yy = probx - ks_cdf(para_nn, scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = probx - ks_cdf(para_nn, scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def t_pdf(dfn, xx):
return (tgamma((dfn + 1.0) / 2.0) * math.pow((1.0 + square(xx) / dfn),\
(-(dfn + 1.0) / 2.0)) / (math.sqrt(dfn * PI) * tgamma(dfn /\
2.0)))
def lf_subtprob(para_nnx, xx):
para_nn = floorl(math.fabs(para_nnx))
ww = math.atan2(xx, math.sqrt(para_nn))
zz = square(math.cos(ww))
yy = 1.0
ii = para_nn - 2.0
while (2.0 <= ii):
yy = 1.0 + (ii - 1.0) / ii * zz * yy
ii -= 2.0
if (iseven(para_nn)):
aa = math.sin(ww) / 2.0
bb = 0.5
else:
if (para_nn == 1):
aa = 0.0
else:
aa = math.sin(ww) * math.cos(ww) / PI
bb = 0.5 + ww / PI
retvalu = bb + aa * yy
if (1.0 < retvalu):
retvalu = 1.0
return (retvalu)
def t_cdf(dfx, xx):
return (lf_subtprob(dfx, xx))
def lf_t_quantile(ndfx, probx):
if (probx < 0.5):
probx = 1.0 - probx
out_sign = -1
else:
out_sign = 1
ux = normal_quantile(probx)
uxsq = square(ux)
aa_x = ((1.0) * uxsq + 1.0) / 4.0
bb_x = (((5.0) * uxsq + 16.0) * uxsq + 3.0) / 96.0
cc_x = ((((3.0) * uxsq + 19.0) * uxsq + 17.0) * uxsq - 15.0) / 384.0
dd_x = (((((79.0) * uxsq + 776.0) * uxsq + 1482.0) * uxsq - 1920.0) *\
uxsq - 945.0) / 92160.0
ee_x = ((((((27.0) * uxsq + 339.0) * uxsq + 930.0) * uxsq - 1782.0) *\
uxsq - 765.0) * uxsq - 17955.0) / 368640.0
retvalu = ux * (1.0 + (aa_x + (bb_x + (cc_x + (dd_x + ee_x / ndfx) /\
ndfx) / ndfx) / ndfx) / ndfx)
if (ndfx <= square(log10(probx)) + 3.0):
nn_a = ndfx + 1.0
while True:
pp_a = lf_subtprob(ndfx, retvalu)
ee_x = (nn_a * math.log(nn_a / (ndfx + square(retvalu))) +\
math.log(ndfx / nn_a / TAU) - 1.0 + (1.0 / nn_a - 1.0 /\
ndfx) / 6.0) / 2.0
if (DBLMAXLN / 2.0 < ee_x):
delta = 0.0
else:
delta = (pp_a - probx) / math.exp(ee_x)
retvalu -= delta
aa_x = math.fabs(delta) * 10000.0
if (iszero(retvalu) or aa_x < retvalu):
break# loop AWAIT
return (out_sign * retvalu)
def t_quantile(dfx, probx):
ndfx = floor(math.fabs(dfx))
if (iszero(probx - 0.5)):
retvalu = 0.0
elif (probx <= 0.0):
retvalu = -DBLMAX
elif (1.0 <= probx):
retvalu = DBLMAX
else:
retvalu = lf_t_quantile(ndfx, probx)
return (retvalu)
def t_cdf__1(dfx, xx):
yy = math.sqrt(dfx + xx * xx)
zz = (xx + yy) / (2.0 * yy)
return (betainc__1(dfx / 2.0, dfx / 2.0, zz))
def t_quantile__1(dfx, probx):
if (not isbetween(probx, 0.0, 1.0)):
scvx_xx = 0.0
else:
scvx_dx = 0.5
scvx_xx = 0.25
scvx_yy = probx - t_cdf(dfx, scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = probx - t_cdf(dfx, scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def f_cdf(dfn_a, dfn_b, xx):
aa = dfn_a / 2.0
bb = dfn_b / 2.0
gg = aa * xx
return (beta_cdf(aa, bb, gg / (bb + gg)))
def lf_subfprob(dfn_a, dfn_b, xx):
if (xx <= 0.0):
retvalu = 1.0
elif (iseven(dfn_b)):
zx = dfn_b / (dfn_b + dfn_a * xx)
ax = 1.0
for ix in range(dfn_b - 2, 0, -2):
ax = 1.0 + (dfn_a + ix - 2.0) / ix * zx * ax
retvalu = 1.0 - (math.pow(1.0 - zx, dfn_a / 2.0) * ax)
elif (iseven(dfn_a)):
zx = dfn_a * xx / (dfn_b + dfn_a * xx)
ax = 1.0
for ix in range(dfn_a - 2, 0, -2):
ax = 1.0 + (dfn_b + ix - 2.0) / ix * zx * ax
retvalu = math.pow(1.0 - zx, dfn_b / 2.0) * ax
else:
yx = math.atan2(math.sqrt(dfn_a * xx / dfn_b), 1.0)
zx = square(math.sin(yx))
if (dfn_a == 1):
ax = 0.0
else:
ax = 1.0
for ix in range(dfn_a - 2, 1, -2):
ax = 1.0 + (dfn_b + ix - 2.0) / ix * zx * ax
bx = PI
for ix in range(2, dfn_b + 1, 2):
bx *= (ix - 1.0) / ix
pp_a = 2.0 / bx * math.sin(yx) * math.pow(math.cos(yx), dfn_b) * ax
zx = square(math.cos(yx))
if (dfn_b == 1):
ax = 0.0
else:
ax = 1.0
for ix in range(dfn_b - 2, 1, -2):
ax = 1.0 + (ix - 1.0) / ix * zx * ax
retvalu = pp_a + 1.0 - 4.0 * (yx + math.sin(yx) * math.cos(yx) *\
ax) / TAU
if (retvalu < 0.0):
retvalu = 0.0
return (retvalu)
def lf_subf_two(nx, qq, pp):
uu = chisqr_cdf(nx, pp)
nxs = nx - 2.0
xx = (uu / nx * (1.0 + ((uu - nxs) / 2.0 + (((4.0 * uu - 11.0 * nxs) *\
uu + nxs * (7.0 * nx - 10.0)) / 24.0 + (((2.0 * uu - 10.0 *\
nxs) * uu + nxs * (17.0 * nx - 26.0)) * uu - nxs * nxs * (9.0\
* nx - 6.0)) / 48.0 / qq) / qq) / qq))
while True:
if (xx <= 0.0):
break
zz = math.exp(((nx + qq) * math.log((nx + qq) / (nx * xx + qq)) +\
(nx - 2.0) * math.log(xx) + math.log(nx * qq / (nx + qq))\
- TWOLN - math.log(TAU) - (1.0 / nx + 1.0 / qq - 1.0 / (nx\
+ qq)) / 6.0) / 2.0)
xx_prev = xx
xx += (lf_subfprob(nx, qq, xx) - pp) / zz
if (iswithin(xx, xx_prev, 0.00001)):
break# loop AWAIT
return (xx)
def lf_subfx(nx, jj, pp):
if (iseq(pp, 1.0)):
retvalu = 0.0
elif (jj == 0):
retvalu = 1.0 / square(t_quantile(nx, 0.5 - pp / 2.0))
elif (nx == 1):
retvalu = square(t_quantile(jj, pp / 2.0))
elif (jj == 2):
uu = chisqr_cdf(jj, 1.0 - pp)
aa = jj - 2.0
retvalu = 1.0 / (uu / jj * (1.0 + ((uu - aa) / 2.0 + (((4.0 * uu -\
11.0 * aa) * uu + aa * (7.0 * jj - 10)) / 24.0 + (((2.0 *\
uu - 10.0 * aa) * uu + aa * (17.0 * jj - 26)) * uu - aa *\
aa * (9.0 * jj - 6.0)) / 48.0 / nx) / nx) / nx))
elif (jj < nx):
retvalu = 1.0 / lf_subf_two(jj, nx, 1.0 - pp)
else:
retvalu = lf_subf_two(nx, jj, pp)
return (retvalu)
def f_quantile(dfn_a, dfn_b, probx):
return (lf_subfx(dfn_a, dfn_b, 1.0 - probx))
def f_quantile__1(dfn_a, dfn_b, probx):
if (probx <= 0.0):
retvalu = 0.0
elif (1.0 <= probx):
retvalu = 1.0
else:
scvx_dx = 0.50
scvx_xx = 0.25
scvx_yy = probx - f_cdf(dfn_a, dfn_b, scvx_xx)
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = probx - f_cdf(dfn_a, dfn_b, scvx_xx)
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
retvalu = scvx_xx
return (retvalu)
def mb_pdf(aa, xx):
return (math.sqrt(4 / TAU) * xx * xx * math.exp(-xx * xx / (2 * aa *\
aa)) / (aa * aa * aa))
def mb_cdf(aa, xx):
return (erf(xx / (TWOSQRT * aa)) - math.sqrt(4 / TAU) * xx *\
math.exp(-xx * xx / (2 * aa * aa)) / aa)
def maxwell_boltzmann_pdf(temperature, molecular_mass, velocity):
aa = math.sqrt(BOLTZMANN * temperature / molecular_mass)
return (mb_pdf(aa, velocity))
def maxwell_boltzmann_cdf(temperature, molecular_mass, velocity):
aa = math.sqrt(BOLTZMANN * temperature / molecular_mass)
return (mb_cdf(aa, velocity))
def maxwell_juttner_pdf(temperature, molecular_mass, velocity):
if (temperature <= 0.0 or velocity <= 0.0 or LIGHT <= velocity or\
molecular_mass <= 0.0):
retvalu = 0.0
else:
rtht = (molecular_mass * LIGHT * LIGHT) / (BOLTZMANN * temperature)
bt = velocity / LIGHT
gmm = 1.0 / topyh1(bt)
dn = bessKn(2, rtht)
if (iszero(dn)):
retvalu = 0.0
else:
retvalu = gmm * gmm * bt * rtht * math.exp(-gmm * rtht) / dn
return (retvalu)
def blackbodyl_pdf(wavelen):
if (wavelen <= 0.0):
retvalu = 0.0
else:
retvalu = math.pow(wavelen, -5.0) / (math.exp(1.0 / wavelen) - 1.0)
return (retvalu * 15.0 / math.pow(PI, 4.0))
def blackbodyf_pdf(freq):
if (freq <= 0.0):
retvalu = 0.0
else:
retvalu = math.pow(freq, 3.0) / (math.exp(freq) - 1.0)
return (retvalu * 15.0 / math.pow(PI, 4.0))
def ints_rand(para_nn, prob_arr_pc):
sum = 0.0
for p_ind in range(0, para_nn + 0, 1):
sum += prob_arr_pc[p_ind]
rndm = randd()
hh = 0.0
for p_ind in range(0, para_nn + 0, 1):
hh += prob_arr_pc[p_ind] / sum
if (rndm < hh):
break
return int(p_ind)
def lf_num2norm(numm):
if (numm <= 1):
retvalu = 0.0
else:
retvalu = 3.0 * math.sqrt(math.log(numm)) - 1.4 - (0.5 *\
math.log(numm) - 0.39) / numm
return (retvalu)
def stdev2spread(numm, stdevx):
if (numm <= 1 or iszero(stdevx)):
retvalu = 0.0
else:
retvalu = (stdevx * lf_num2norm(numm))
return (retvalu)
def spread2stdev(numm, spread):
if (numm <= 1 or iszero(spread)):
retvalu = 0.0
else:
retvalu = (spread / lf_num2norm(numm))
return (retvalu)
def maxabs(nn, data_arr_pc):
maxaby = data_arr_pc[0]
amaxaby = math.fabs(maxaby)
for ii in range(1, nn + 0, 1):
atemp = math.fabs(data_arr_pc[ii])
if (amaxaby < atemp):
maxaby = data_arr_pc[ii]
amaxaby = atemp
return (maxaby)
def minabs(nn, data_arr_pc):
minaby = data_arr_pc[0]
aminaby = math.fabs(minaby)
for ii in range(1, nn + 0, 1):
atemp = math.fabs(data_arr_pc[ii])
if (atemp < aminaby):
minaby = data_arr_pc[ii]
aminaby = atemp
return (minaby)
def maxabsoffset(offset, nn, data_arr_pc):
maxaby = data_arr_pc[0] - offset
for ii in range(1, nn + 0, 1):
delta = data_arr_pc[ii] - offset
if (math.fabs(maxaby) < math.fabs(delta)):
maxaby = delta
return (maxaby + offset)
def minabsoffset(offset, nn, data_arr_pc):
minaby = data_arr_pc[0] - offset
for ii in range(1, nn + 0, 1):
delta = data_arr_pc[ii] - offset
if (math.fabs(delta) < math.fabs(minaby)):
minaby = delta
return (minaby + offset)
def mini(num, data_arr_pc):
curr = data_arr_pc[0]
for ii in range(1, num + 0, 1):
tmp = data_arr_pc[ii]
if (tmp < curr):
curr = tmp
return (curr)
def maxi(num, data_arr_pc):
curr = data_arr_pc[0]
for ii in range(1, num + 0, 1):
tmp = data_arr_pc[ii]
if (curr < tmp):
curr = tmp
return (curr)
def maxmin(num, data_arr_pc, ret_maxmin_arr_p):
minn = data_arr_pc[0]
maxx = data_arr_pc[0]
for ii in range(1, num + 0, 1):
tmp = data_arr_pc[ii]
if (minn < tmp):
minn = tmp
if (tmp < maxx):
maxx = tmp
ret_maxmin_arr_p[0] = maxx
ret_maxmin_arr_p[1] = minn
return (maxx - minn)
def min2(value_a, value_b):
if (value_a < value_b):
retvalu = value_a
else:
retvalu = value_b
return (retvalu)
def max2(value_a, value_b):
if (value_b < value_a):
retvalu = value_a
else:
retvalu = value_b
return (retvalu)
def minabs2(value_a, value_b):
if (math.fabs(value_a) < math.fabs(value_b)):
retvalu = value_a
else:
retvalu = value_b
return (retvalu)
def maxabs2(value_a, value_b):
if (math.fabs(value_b) < math.fabs(value_a)):
retvalu = value_a
else:
retvalu = value_b
return (retvalu)
def variance(nn, xx_arr_pc):
meanx = 0.0
variancex = 0.0
for ii in range(0, nn + 0, 1):
delta = xx_arr_pc[ii] - meanx
meanx += delta / (ii + 1.0)
variancex += delta * (xx_arr_pc[ii] - meanx)
if (2 <= nn):
variancex /= (nn - 1.0)
else:
variancex = 0.0
return (variancex)
def mean(nn, xx_arr_pc):
meanx = 0.0
for ii in range(0, nn + 0, 1):
delta = xx_arr_pc[ii] - meanx
meanx += delta / (ii + 1.0)
return (meanx)
LC_STTS_NUM = 0
LC_STTS_MEAN = 1
LC_STTS_MSQ = 2
LC_STTS_MAX = 3
LC_STTS_MIN = 4
LC_STTS_MAGIC = 5
LC_STTS_CNT = 6
LC_STTS_KEY_CNT = 100
lv_sttx_mtrx = [[0 for ii in range(LC_STTS_CNT)] for ii in\
range(LC_STTS_KEY_CNT)]
def lf_stts_is_inited(ix_hndl):
global lv_sttx_mtrx
vll = lv_sttx_mtrx[0][LC_STTS_MAGIC]
if (vll != magicset() and vll != magicnot()):
for ii in range(0, LC_STTS_KEY_CNT + 0, 1):
for jj in range(0, LC_STTS_MAGIC + 0, 1):
lv_sttx_mtrx[ii][jj] = 0.0
lv_sttx_mtrx[0][LC_STTS_MAGIC] = magicnot()
if (LC_STTS_KEY_CNT <= ix_hndl):
retvalu_bol = False
else:
vll = lv_sttx_mtrx[ix_hndl][LC_STTS_MAGIC]
retvalu_bol = ismagic(vll)
return (retvalu_bol)
def lf_stts_find_empty():
ix_hndl = 0
while (lf_stts_is_inited(ix_hndl)):
ix_hndl += 1
if (LC_STTS_KEY_CNT <= ix_hndl):
sys.stderr.write("lf_stts_find_empty:" + "STTS-Bad-handle")
sys.exit(1)
return int(ix_hndl)
def stts_init(ix_hndl, n_count, meanx, var, minim, maxim):
global lv_sttx_mtrx
lv_sttx_mtrx[ix_hndl][LC_STTS_NUM] = n_count
lv_sttx_mtrx[ix_hndl][LC_STTS_MEAN] = meanx
lv_sttx_mtrx[ix_hndl][LC_STTS_MSQ] = var * (n_count - 1.0)
lv_sttx_mtrx[ix_hndl][LC_STTS_MIN] = minim
lv_sttx_mtrx[ix_hndl][LC_STTS_MAX] = maxim
lv_sttx_mtrx[ix_hndl][LC_STTS_MAGIC] = magicset()
return int(ix_hndl)
def stts_initx(ix_hndl, num_count, meanx, msq, minim, maxim):
global lv_sttx_mtrx
lv_sttx_mtrx[ix_hndl][LC_STTS_NUM] = num_count
lv_sttx_mtrx[ix_hndl][LC_STTS_MEAN] = meanx
lv_sttx_mtrx[ix_hndl][LC_STTS_MSQ] = msq
lv_sttx_mtrx[ix_hndl][LC_STTS_MIN] = minim
lv_sttx_mtrx[ix_hndl][LC_STTS_MAX] = maxim
lv_sttx_mtrx[ix_hndl][LC_STTS_MAGIC] = magicset()
return int(ix_hndl)
def stts_reset(ix_hndl):
return int((stts_init(ix_hndl, 0.0, 0.0, 0.0, 1.0, 0.0)))
def stts_new():
ix_hndl = lf_stts_find_empty()
return int((stts_reset(ix_hndl)))
def stts_delete(ix_hndl):
global lv_sttx_mtrx
lv_sttx_mtrx[ix_hndl][LC_STTS_MAGIC] = magicnot()
return int(ix_hndl)
def sttscount(ix_hndl):
global lv_sttx_mtrx
return (lv_sttx_mtrx[ix_hndl][LC_STTS_NUM])
def sttsmean(ix_hndl):
global lv_sttx_mtrx
return (lv_sttx_mtrx[ix_hndl][LC_STTS_MEAN])
def sttsmsq(ix_hndl):
global lv_sttx_mtrx
return (lv_sttx_mtrx[ix_hndl][LC_STTS_MSQ])
def sttsmax(ix_hndl):
global lv_sttx_mtrx
return (lv_sttx_mtrx[ix_hndl][LC_STTS_MAX])
def sttsmin(ix_hndl):
global lv_sttx_mtrx
return (lv_sttx_mtrx[ix_hndl][LC_STTS_MIN])
def sttsmagic(ix_hndl):
global lv_sttx_mtrx
return (lv_sttx_mtrx[ix_hndl][LC_STTS_MAGIC])
def sttssum(ix_hndl):
return (sttsmean(ix_hndl) * sttscount(ix_hndl))
def sttsvar(ix_hndl):
if (math.fabs(sttscount(ix_hndl)) <= 1.0):
retvalu = 0.0
else:
retvalu = (sttsmsq(ix_hndl) / (math.fabs(sttscount(ix_hndl) - 1.0)))
return (retvalu)
def sttsstdev(ix_hndl):
if (sttscount(ix_hndl) <= 1.0):
retvalu = 0.0
else:
retvalu = (math.sqrt(sttsmsq(ix_hndl) / (sttscount(ix_hndl) - 1.0)))
return (retvalu)
def sttsstdevmean(ix_hndl):
if (sttscount(ix_hndl) <= 1.0 or sttsmsq(ix_hndl) <= 0.0):
retvalu = 0.0
else:
retvalu = (math.sqrt(sttsmsq(ix_hndl)) / (sttscount(ix_hndl) - 1.0))
return (retvalu)
def sttsspread(ix_hndl):
return (sttsmax(ix_hndl) - sttsmin(ix_hndl))
def stts_update(ix_hndl, new_data):
global lv_sttx_mtrx
if (not lf_stts_is_inited(ix_hndl)):
sys.stderr.write("stts_update:" + "STTS-Bad-handle")
sys.exit(1)
delta = new_data - lv_sttx_mtrx[ix_hndl][LC_STTS_MEAN]
lv_sttx_mtrx[ix_hndl][LC_STTS_NUM] += 1.0
numy = lv_sttx_mtrx[ix_hndl][LC_STTS_NUM]
lv_sttx_mtrx[ix_hndl][LC_STTS_MEAN] += (delta / numy)
lv_sttx_mtrx[ix_hndl][LC_STTS_MSQ] += (delta * (new_data -\
lv_sttx_mtrx[ix_hndl][LC_STTS_MEAN]))
if ((numy < 2.0 or sttsspread(ix_hndl) < 0.0)):
lv_sttx_mtrx[ix_hndl][LC_STTS_MIN] = new_data
lv_sttx_mtrx[ix_hndl][LC_STTS_MAX] = new_data
else:
if (new_data < lv_sttx_mtrx[ix_hndl][LC_STTS_MIN]):
lv_sttx_mtrx[ix_hndl][LC_STTS_MIN] = new_data
if (lv_sttx_mtrx[ix_hndl][LC_STTS_MAX] < new_data):
lv_sttx_mtrx[ix_hndl][LC_STTS_MAX] = new_data
return (delta)
def stts_downdate(ix_hndl, old_data):
if (not lf_stts_is_inited(ix_hndl)):
sys.stderr.write("stts_downdate:" + "STTS-Bad-handle")
sys.exit(1)
men = lv_sttx_mtrx[ix_hndl][LC_STTS_MEAN]
delt = old_data - men
if (0.0 < lv_sttx_mtrx[ix_hndl][LC_STTS_NUM]):
lv_sttx_mtrx[ix_hndl][LC_STTS_NUM] -= 1
if (0.0 < lv_sttx_mtrx[ix_hndl][LC_STTS_NUM]):
men -= delt / lv_sttx_mtrx[ix_hndl][LC_STTS_NUM]
lv_sttx_mtrx[ix_hndl][LC_STTS_MEAN] = men
lv_sttx_mtrx[ix_hndl][LC_STTS_MSQ] -= delt * (old_data - men)
if (lv_sttx_mtrx[ix_hndl][LC_STTS_MSQ] < 0.0):
lv_sttx_mtrx[ix_hndl][LC_STTS_MSQ] = 0.0
else:
lv_sttx_mtrx[ix_hndl][LC_STTS_MSQ] = 0.0
lv_sttx_mtrx[ix_hndl][LC_STTS_MEAN] = 0.0
return (delt)
def stts_updatex(ix_hndl, nn, data_arr_pc):
retvalu = 0.0
for ii in range(0, nn + 0, 1):
retvalu += stts_update(ix_hndl, data_arr_pc[ii])
return (retvalu)
def stts_newx(nn, data_arr_pc):
ihndl = stts_new()
for ii in range(0, nn + 0, 1):
stts_update(ihndl, data_arr_pc[ii])
return int(ihndl)
def stts_shift(ix_hndl, data_shift):
global lv_sttx_mtrx
lv_sttx_mtrx[ix_hndl][LC_STTS_MAX] += data_shift
lv_sttx_mtrx[ix_hndl][LC_STTS_MIN] += data_shift
lv_sttx_mtrx[ix_hndl][LC_STTS_MEAN] += data_shift
return int(ix_hndl)
def stts_scale(ix_hndl, xfactor):
global lv_sttx_mtrx
if (0 < xfactor):
newmax = lv_sttx_mtrx[ix_hndl][LC_STTS_MAX] * xfactor
newmin = lv_sttx_mtrx[ix_hndl][LC_STTS_MIN] * xfactor
else:
newmax = lv_sttx_mtrx[ix_hndl][LC_STTS_MIN] * xfactor
newmin = lv_sttx_mtrx[ix_hndl][LC_STTS_MAX] * xfactor
lv_sttx_mtrx[ix_hndl][LC_STTS_MIN] = newmin
lv_sttx_mtrx[ix_hndl][LC_STTS_MAX] = newmax
lv_sttx_mtrx[ix_hndl][LC_STTS_MEAN] *= xfactor
lv_sttx_mtrx[ix_hndl][LC_STTS_MSQ] *= xfactor * xfactor
return int(ix_hndl)
def stts_copy(hto, hfrom):
global lv_sttx_mtrx
for ii in range(0, LC_STTS_CNT + 0, 1):
lv_sttx_mtrx[hto][ii] = lv_sttx_mtrx[hfrom][ii]
return int(hto)
def stts_update2(ix_hnda, ix_hndb):
if (not lf_stts_is_inited(ix_hndb)):
sys.stderr.write("stts_update2:" + "STTS-Bad-hndb")
sys.exit(1)
nb = sttscount(ix_hndb)
if (not iszero(nb)):
if (not lf_stts_is_inited(ix_hnda)):
sys.stderr.write("stts_update2:" + "STTS-Bad-hnda")
sys.exit(1)
if (iszero(sttscount(ix_hnda))):
stts_copy(ix_hnda, ix_hndb)
else:
delta = sttsmean(ix_hndb) - sttsmean(ix_hnda)
ncount = nb + sttscount(ix_hnda)
nmean = sttsmean(ix_hnda) + delta * nb / ncount
nmsqr = (sttsmsq(ix_hnda) + sttsmsq(ix_hndb) + delta * delta *\
sttscount(ix_hnda) * nb / ncount)
amin = sttsmin(ix_hnda)
amax = sttsmax(ix_hnda)
bmin = sttsmin(ix_hndb)
bmax = sttsmax(ix_hndb)
if (amax < amin):
amin = bmin
amax = bmax
else:
if (bmin < amin):
amin = bmin
if (amax < bmax):
amax = bmax
stts_init(ix_hnda, ncount, nmean, nmsqr / (ncount - 1.0), amin,\
amax)
return int(ix_hnda)
LC_STTSC_XX = 0
LC_STTSC_YY = 1
LC_STTSC_COVAR = 2
LC_STTSC_MAGIC = 3
LC_STTSC_CNT = 4
lv_crx_mtrx = [[0 for ii in range(LC_STTSC_CNT)] for ii in\
range(LC_STTS_KEY_CNT)]
def lf_corr_is_init(ix_chnd):
global lv_crx_mtrx
if (LC_STTS_KEY_CNT <= ix_chnd):
retvalu_bol = False
else:
vll = lv_crx_mtrx[ix_chnd][LC_STTSC_MAGIC]
retvalu_bol = ismagic(vll)
return (retvalu_bol)
def lf_corr_find_empty():
ix_chnd = 0
while (lf_corr_is_init(ix_chnd)):
ix_chnd += 1
if (LC_STTS_KEY_CNT <= ix_chnd):
sys.stderr.write("lf_corr_find_empty:" + "STTS-No-empty-handle")
sys.exit(1)
return int(ix_chnd)
def corr_new():
global lv_crx_mtrx
ix_chnd = lf_corr_find_empty()
lv_crx_mtrx[ix_chnd][LC_STTSC_XX] = stts_new()
lv_crx_mtrx[ix_chnd][LC_STTSC_YY] = stts_new()
lv_crx_mtrx[ix_chnd][LC_STTSC_COVAR] = 0.0
lv_crx_mtrx[ix_chnd][LC_STTSC_MAGIC] = magicset()
return int(ix_chnd)
def corr_delete(ix_chnd):
global lv_crx_mtrx
lv_crx_mtrx[ix_chnd][LC_STTSC_MAGIC] = magicnot()
stts_delete(lv_crx_mtrx[ix_chnd][LC_STTSC_XX])
stts_delete(lv_crx_mtrx[ix_chnd][LC_STTSC_YY])
return int(ix_chnd)
def corr_handlex(ix_chnd):
global lv_crx_mtrx
return int(lv_crx_mtrx[ix_chnd][LC_STTSC_XX])
def corr_handley(ix_chnd):
global lv_crx_mtrx
return int(lv_crx_mtrx[ix_chnd][LC_STTSC_YY])
def corr_update(ix_chnd, xx, yy):
global lv_crx_mtrx
yyhnd = lv_crx_mtrx[ix_chnd][LC_STTSC_YY]
xxhnd = lv_crx_mtrx[ix_chnd][LC_STTSC_XX]
num = sttscount(xxhnd)
ddxx = stts_update(xxhnd, xx)
ddyy = stts_update(yyhnd, yy)
lv_crx_mtrx[ix_chnd][LC_STTSC_COVAR] += (ddxx * ddyy * num / (num + 1.0))
return (lv_crx_mtrx[ix_chnd][LC_STTSC_COVAR])
def corrslope(ix_chnd):
global lv_crx_mtrx
xxhnd = lv_crx_mtrx[ix_chnd][LC_STTSC_XX]
den = sttsmsq(xxhnd)
if (iszero(den)):
retvalu = 0.0
else:
retvalu = lv_crx_mtrx[ix_chnd][LC_STTSC_COVAR] / den
return (retvalu)
def corry0(ix_chnd):
global lv_crx_mtrx
yyhnd = lv_crx_mtrx[ix_chnd][LC_STTSC_YY]
xxhnd = lv_crx_mtrx[ix_chnd][LC_STTSC_XX]
retvalu = (sttsmean(yyhnd) - corrslope(ix_chnd) * sttsmean(xxhnd))
return (retvalu)
def corrcorr(ix_chnd):
global lv_crx_mtrx
xxmsq = sttsmsq(lv_crx_mtrx[ix_chnd][LC_STTSC_XX])
yymsq = sttsmsq(lv_crx_mtrx[ix_chnd][LC_STTSC_YY])
den = xxmsq * yymsq
if (iszero(den)):
retvalu = 0.0
else:
retvalu = (lv_crx_mtrx[ix_chnd][LC_STTSC_COVAR] / math.sqrt(den))
return (retvalu)
def corrstderr(ix_chnd):
global lv_crx_mtrx
yyhnd = lv_crx_mtrx[ix_chnd][LC_STTSC_YY]
diff = sttsmsq(yyhnd) - (corrslope(ix_chnd) *\
lv_crx_mtrx[ix_chnd][LC_STTSC_COVAR])
if (diff < 0.0):
retvalu = 0.0
else:
retvalu = math.sqrt(diff / (sttscount(yyhnd) - 2.0))
return (retvalu)
def fit_poly(num_points, pts_arr_pc, ret_coeff_arr_p):
cc_arr = []
for nzzn in range(len(cc_arr), int(num_points)):
cc_arr.append(0)
for j_ind in range(0, num_points + 0, 1):
cc_arr[j_ind] = pts_arr_pc[2 * j_ind + 1]
for j_ind in range(1, num_points + 0, 1):
k_ind = num_points - 1 - j_ind
for i_ind in range(num_points - 1, j_ind - 1, -1):
cc_arr[i_ind] = ((cc_arr[i_ind - 1] - cc_arr[i_ind]) /\
(pts_arr_pc[2 * k_ind] - pts_arr_pc[2 * i_ind]))
k_ind -= 1
for j_ind in range(0, num_points - 1, 1):
for i_ind in range(num_points - 2, j_ind - 1, -1):
prod = cc_arr[i_ind + 1] * pts_arr_pc[2 * (i_ind - j_ind)]
cc_arr[i_ind] -= prod
for j_ind in range(0, num_points + 0, 1):
ret_coeff_arr_p[j_ind] = cc_arr[j_ind]
return (num_points)
LC_PARABOLA_X_AXIS = 0
LC_PARABOLA_Y_EXTREMA = 1
LC_PARABOLA_REAL_ROOTS = 2
LC_PARABOLA_ROOT_A = 3
LC_PARABOLA_ROOT_B = 4
LC_PARABOLA_COEFF_C = 5
LC_PARABOLA_COEFF_B = 6
LC_PARABOLA_COEFF_A = 7
lv_parabola_arr = [0 for ii in range(8)]
def parabola_solve(xx_a, yy_a, xx_b, yy_b, xx_c, yy_c):
global lv_parabola_arr
pts_arr = [0 for ii in range(8)]
cc_arr = [0 for ii in range(4)]
roots_arr = [0 for ii in range(2)]
pts_arr[0] = xx_a
pts_arr[1] = yy_a
pts_arr[2] = xx_b
pts_arr[3] = yy_b
pts_arr[4] = xx_c
pts_arr[5] = yy_c
fit_poly(3, pts_arr, cc_arr)
roots_arr[0] = DBLMAX
roots_arr[1] = DBLMAX
if (iszero(cc_arr[2])):
axis = DBLMAX
if (iszero(cc_arr[1])):
yyextrema = cc_arr[0]
real_roots = 0
else:
yyextrema = DBLMAX
real_roots = 1
roots_arr[0] = (-cc_arr[0] / cc_arr[1])
else:
axis = (-cc_arr[1] / (2.0 * cc_arr[2]))
yyextrema = (cc_arr[0] + xx_a * (cc_arr[1] + xx_a * cc_arr[2]))
disc = (cc_arr[1] * cc_arr[1] - 4.0 * cc_arr[2] * cc_arr[0])
if (iszero(disc)):
real_roots = 1
roots_arr[0] = axis
elif (0 < disc):
disc = math.sqrt(disc) / (2.0 * cc_arr[2])
real_roots = 2
roots_arr[0] = axis - disc
roots_arr[1] = axis + disc
else:
real_roots = 0
lv_parabola_arr[LC_PARABOLA_X_AXIS] = axis
lv_parabola_arr[LC_PARABOLA_Y_EXTREMA] = yyextrema
lv_parabola_arr[LC_PARABOLA_REAL_ROOTS] = real_roots
lv_parabola_arr[LC_PARABOLA_ROOT_A] = roots_arr[0]
lv_parabola_arr[LC_PARABOLA_ROOT_B] = roots_arr[1]
lv_parabola_arr[LC_PARABOLA_COEFF_C] = cc_arr[0]
lv_parabola_arr[LC_PARABOLA_COEFF_B] = cc_arr[1]
lv_parabola_arr[LC_PARABOLA_COEFF_A] = cc_arr[2]
return (axis)
def parabola_get(ii_ind):
global lv_parabola_arr
if (0 <= ii_ind and ii_ind <= 7):
retvalu = lv_parabola_arr[ii_ind]
else:
retvalu = 0
return (retvalu)
def parabola_roots(ii_ind):
if (0 <= ii_ind and ii_ind <= 1):
retvalu = parabola_get(ii_ind + LC_PARABOLA_ROOT_A)
else:
retvalu = DBLMAX
return (retvalu)
def parabola_yextrema():
return (parabola_get(LC_PARABOLA_Y_EXTREMA))
def parabola_xaxis():
return (parabola_get(LC_PARABOLA_X_AXIS))
def parabola_realroots():
return (parabola_get(LC_PARABOLA_REAL_ROOTS))
LC_CIRCLE_X = 0
LC_CIRCLE_Y = 1
LC_CIRCLE_RADIUS = 2
lv_circle_arr = [0 for ii in range(3)]
def circle_solve(x_a, y_a, x_b, y_b, x_c, y_c):
global lv_circle_arr
y_ba = y_b - y_a
x_ba = x_b - x_a
y_ca = y_c - y_a
x_ca = x_c - x_a
det = 2.0 * (y_ba * x_ca - y_ca * x_ba)
if (not iszero(det)):
xy_ba = y_ba * (y_a + y_b) + x_ba * (x_a + x_b)
xy_ca = y_ca * (y_a + y_c) + x_ca * (x_a + x_c)
center_x = (y_ba * xy_ca - y_ca * xy_ba) / det
center_y = (x_ca * xy_ba - x_ba * xy_ca) / det
radius = hypot(center_x - x_a, center_y - y_a)
else:
center_x = DBLMAX
center_y = DBLMAX
radius = DBLMAX
lv_circle_arr[LC_CIRCLE_X] = center_x
lv_circle_arr[LC_CIRCLE_Y] = center_y
lv_circle_arr[LC_CIRCLE_RADIUS] = radius
return (radius)
def circle_get(ii_ind):
global lv_circle_arr
if (0 <= ii_ind and ii_ind <= 2):
retvalu = lv_circle_arr[ii_ind]
else:
retvalu = 0
return (retvalu)
def fit_minmax(num_points, pt_arr_pc, ret_coeff_arr_p):
xxp_arr = []
yyp_arr = []
for nzzn in range(len(xxp_arr), int(num_points)):
xxp_arr.append(0)
for nzzn in range(len(yyp_arr), int(num_points)):
yyp_arr.append(0)
epsxx = 0.0
epsyy = 0.0
for j_ind in range(0, num_points + 0, 1):
xxp_arr[j_ind] = pt_arr_pc[2 * j_ind]
yyp_arr[j_ind] = pt_arr_pc[2 * j_ind + 1]
if (epsxx < math.fabs(xxp_arr[j_ind])):
epsxx = math.fabs(xxp_arr[j_ind])
if (epsyy < math.fabs(yyp_arr[j_ind])):
epsyy = math.fabs(yyp_arr[j_ind])
nx_spr = -1
nx_a = 0
nx_b = 0
epsxx *= 16 * DBLEPS
epsyy *= 16 * DBLEPS
for i_ind in range(1, num_points + 0, 1):
for j_ind in range(0, i_ind + 0, 1):
dxx = xxp_arr[i_ind] - xxp_arr[j_ind]
if (epsxx < math.fabs(dxx)):
slope_t = (yyp_arr[i_ind] - yyp_arr[j_ind]) / dxx
intercept_t = yyp_arr[i_ind] - slope_t * xxp_arr[i_ind]
pty = slope_t * xxp_arr[0] + intercept_t
dyy = yyp_arr[0] - pty
min_dyy = dyy
max_dyy = dyy
k_ind = 1
while (k_ind < num_points):
pty = slope_t * xxp_arr[k_ind] + intercept_t
dyy = yyp_arr[k_ind] - pty
if (dyy < min_dyy):
min_dyy = dyy
if (max_dyy < dyy):
max_dyy = dyy
this_spr = max_dyy - min_dyy
if ((0 < nx_spr and nx_spr + epsyy < this_spr) or (min_dyy\
< - epsyy and epsyy < max_dyy)):
break
k_ind += 1
if (num_points <= k_ind):
if ((this_spr <= nx_spr + epsyy and math.fabs(nx_a) <\
math.fabs(slope_t)) or nx_spr < 0 or this_spr <\
nx_spr - epsyy):
nx_spr = this_spr
nx_a = slope_t
nx_b = intercept_t + (min_dyy + max_dyy) / 2.0
ret_coeff_arr_p[1] = nx_a
ret_coeff_arr_p[0] = nx_b
ret_coeff_arr_p[2] = nx_spr / 2.0
return (nx_spr / 2.0)
def lf_signcrossproduct(x_a, y_a, x_b, y_b, x_c, y_c):
bbx_a = x_b - x_a
bby_a = y_b - y_a
ccx_a = x_c - x_a
ccy_a = y_c - y_a
cr = bbx_a * ccy_a - ccx_a * bby_a
return (cr)
def fitx_minmax(num_points, pt_arr_pc, ret_arr_p):
xxp_arr = []
yyp_arr = []
chi_arr = []
for nzzn in range(len(xxp_arr), int(num_points)):
xxp_arr.append(0)
for nzzn in range(len(yyp_arr), int(num_points)):
yyp_arr.append(0)
for nzzn in range(len(chi_arr), int(num_points)):
chi_arr.append(0)
epsxx = 0.0
epsyy = 0.0
lmbm_ind = 0
for j_ind in range(0, num_points + 0, 1):
xxp_arr[j_ind] = pt_arr_pc[2 * j_ind]
yyp_arr[j_ind] = pt_arr_pc[2 * j_ind + 1]
if (epsxx < math.fabs(xxp_arr[j_ind])):
epsxx = math.fabs(xxp_arr[j_ind])
if (epsyy < math.fabs(yyp_arr[j_ind])):
epsyy = math.fabs(yyp_arr[j_ind])
if (xxp_arr[j_ind] <= xxp_arr[lmbm_ind]):
if (xxp_arr[j_ind] < xxp_arr[lmbm_ind] or yyp_arr[j_ind] <=\
yyp_arr[lmbm_ind]):
lmbm_ind = j_ind
nx_spr = -1
nx_a = 0
nx_b = 0
epsxx *= 16 * DBLEPS
epsyy *= 16 * DBLEPS
poh_ind = lmbm_ind
chisize = 0
while True:
chi_arr[chisize] = poh_ind
e_ind = 0
for j_ind in range(0, num_points + 0, 1):
if (e_ind == poh_ind):
e_ind = j_ind
else:
t_ind = chi_arr[chisize]
crx = lf_signcrossproduct(xxp_arr[j_ind], yyp_arr[j_ind],\
xxp_arr[t_ind], yyp_arr[t_ind], xxp_arr[e_ind],\
yyp_arr[e_ind])
if (crx < 0):
e_ind = j_ind
chisize += 1
if (num_points < chisize):
sys.stderr.write("fitx_minmax:" + "OOPS")
sys.exit(1)
poh_ind = e_ind
if (e_ind == chi_arr[0]):
break# loop AWAIT
chi_arr[chisize] = chi_arr[0]
chisize += 1
for hh in range(0, chisize - 1, 1):
i_ind = chi_arr[hh]
j_ind = chi_arr[hh + 1]
dxx = xxp_arr[i_ind] - xxp_arr[j_ind]
if (epsxx < math.fabs(dxx)):
slope_t = (yyp_arr[i_ind] - yyp_arr[j_ind]) / dxx
intercept_t = yyp_arr[i_ind] - slope_t * xxp_arr[i_ind]
dyy = yyp_arr[0] - (slope_t * xxp_arr[0] + intercept_t)
min_dyy = dyy
max_dyy = dyy
this_spr = 0
k_ind = 1
while (k_ind < num_points):
pty = (slope_t * xxp_arr[k_ind] + intercept_t)
dyy = yyp_arr[k_ind] - pty
if (dyy < min_dyy):
min_dyy = dyy
if (max_dyy < dyy):
max_dyy = dyy
this_spr = max_dyy - min_dyy
if ((0 < nx_spr and nx_spr + epsyy < this_spr) or (min_dyy <\
- epsyy and epsyy < max_dyy)):
break
k_ind += 1
if (num_points <= k_ind):
if ((this_spr <= nx_spr + epsyy and math.fabs(nx_a) <\
math.fabs(slope_t)) or nx_spr < 0 or this_spr <\
nx_spr - epsyy):
nx_a = slope_t
nx_b = intercept_t + (min_dyy + max_dyy) / 2.0
nx_spr = this_spr
ret_arr_p[0] = nx_b
ret_arr_p[1] = nx_a
ret_arr_p[2] = nx_spr / 2.0
return (ret_arr_p[2])
def fit_minmax0(num_points, pts_arr_pc, ret_arr_p):
xxp_arr = []
yyp_arr = []
for nzzn in range(len(xxp_arr), int(num_points)):
xxp_arr.append(0)
for nzzn in range(len(yyp_arr), int(num_points)):
yyp_arr.append(0)
epsxx = 0.0
epsyy = 0.0
for j_ind in range(0, num_points + 0, 1):
xxp_arr[j_ind] = pts_arr_pc[2 * j_ind]
yyp_arr[j_ind] = pts_arr_pc[2 * j_ind + 1]
if (epsxx < math.fabs(xxp_arr[j_ind])):
epsxx = math.fabs(xxp_arr[j_ind])
if (epsyy < math.fabs(yyp_arr[j_ind])):
epsyy = math.fabs(yyp_arr[j_ind])
mnmxz_spread = -1
mnmxz_slope = 0
mnmxz_intercept = yyp_arr[0]
epsxx *= 8 * DBLEPS
epsyy *= 8 * DBLEPS
for i_ind in range(2, num_points + 0, 1):
for j_ind in range(2, i_ind + 0, 1):
midxx = (xxp_arr[i_ind] + xxp_arr[j_ind]) / 2.0
midyy = (yyp_arr[i_ind] + yyp_arr[j_ind]) / 2.0
dxx = xxp_arr[0] - midxx
if (epsxx < math.fabs(dxx)):
slope_t = (yyp_arr[0] - midyy) / dxx
intercept_t = yyp_arr[0] - slope_t * xxp_arr[0]
min_dyy = 0
max_dyy = 0
for k_ind in range(0, num_points + 0, 1):
pty = slope_t * xxp_arr[k_ind] + intercept_t
dyy = yyp_arr[k_ind] - pty
if (dyy < min_dyy):
min_dyy = dyy
if (max_dyy < dyy):
max_dyy = dyy
this_spr = max_dyy - min_dyy
if (0 < mnmxz_spread and mnmxz_spread + epsyy < this_spr):
break
if (mnmxz_spread < 0 or this_spr < mnmxz_spread - epsyy):
mnmxz_slope = slope_t
mnmxz_intercept = intercept_t
mnmxz_spread = this_spr
if (0 <= mnmxz_spread):
ret_arr_p[1] = mnmxz_slope
ret_arr_p[0] = mnmxz_intercept
ret_arr_p[2] = mnmxz_spread / 2.0
return (mnmxz_spread / 2.0)
def fit_ls(num_points, pts_arr_pc, ret_arr_p):
mean_xx = 0.0
ssq_xx = 0.0
mean_yy = 0.0
ssq_yy = 0.0
covariance_xy = 0.0
for i_ind in range(0, num_points + 0, 1):
xx = pts_arr_pc[2 * i_ind]
dxx = xx - mean_xx
mean_xx += dxx / (i_ind + 1)
ssq_xx += dxx * (xx - mean_xx)
yy = pts_arr_pc[2 * i_ind + 1]
dyy = yy - mean_yy
mean_yy += dyy / (i_ind + 1)
ssq_yy += dyy * (yy - mean_yy)
covariance_xy += dxx * dyy * i_ind / (i_ind + 1.0)
slope = covariance_xy / ssq_xx
ret_arr_p[1] = slope
ret_arr_p[0] = mean_yy - slope * mean_xx
ret_arr_p[2] = covariance_xy / math.sqrt(ssq_xx * ssq_yy)
ret_arr_p[3] = math.sqrt((ssq_yy - slope * covariance_xy) /\
(num_points - 2))
return (ret_arr_p[2])
def fit_ls0(num_points, pts_arr_pc, ret_lsz_arr_p):
xxsum = 0.0
xysum = 0.0
for i_ind in range(1, num_points + 0, 1):
j_ind = 2 * i_ind
dxx = (pts_arr_pc[j_ind] - pts_arr_pc[0])
xxsum += dxx * dxx
xysum += dxx * (pts_arr_pc[j_ind + 1] - pts_arr_pc[1])
slope = xysum / xxsum
ret_lsz_arr_p[1] = slope
ret_lsz_arr_p[0] = (pts_arr_pc[1] - slope * pts_arr_pc[0])
return (slope)
def sqrt__1(xx):
if (xx <= 0.0):
yy_curr = 0.0
else:
power_of_two = 1.0
zz = xx
while (4.0 <= zz):
zz /= 4.0
power_of_two *= 2.0
while (zz < 1.0):
zz *= 4.0
power_of_two /= 2.0
yy_curr = (((-0.0353026277858345) * zz + 0.502513025246083) * zz +\
0.546382637992462)
while True:
yy_prev = yy_curr
yy_curr = (yy_curr + zz / yy_curr) / 2.0
if (iseq(yy_prev, yy_curr)):
break# loop AWAIT
yy_curr *= power_of_two
return (yy_curr)
def sqrt__2(xx):
if (xx <= 0.0):
scvx_xx = 0.0
else:
if (1.0 < xx):
ini = xx / 2.0
else:
ini = 2.0 * xx
scvx_dx = ini / 10.0
scvx_xx = ini
scvx_yy = xx - scvx_xx * scvx_xx
for scvx_ii in range(0, 21, 1):
scvx_xp = scvx_xx
scvx_yp = scvx_yy
scvx_xx += scvx_dx
if (iseq(scvx_xp, scvx_xx)):
break
scvx_yy = xx - scvx_xx * scvx_xx
if (iseq(scvx_yy, scvx_yp)):
break
scvx_dx *= - scvx_yy / (scvx_yy - scvx_yp)
return (scvx_xx)
def sqrt__3(yy):
if (yy <= 0.0):
nrvx_xx = 0.0
else:
if (1.0 < yy):
ini = yy / 2.0
else:
ini = 2.0 * yy
nrvx_xx = ini
for nrvx_ii in range(0, 21, 1):
nrvx_xp = nrvx_xx
nrvx_dy = 2.0 * nrvx_xx
if (iszero(nrvx_dy)):
break
nrvx_yy = nrvx_xx * nrvx_xx - yy
nrvx_xx -= nrvx_yy / nrvx_dy
if (iseq(nrvx_xp, nrvx_xx)):
break
return (nrvx_xx)
def nthroot__1(xx, kk):
if (xx <= 0.0):
yy_curr = 0.0
else:
yy_curr = xx / 2.0
while True:
yy_prev = yy_curr
pp = yy_curr
for ii in range(2, kk + 0, 1):
pp *= yy_curr
yy_curr = (yy_curr * (kk - 1.0) + xx / pp) / kk
if (iseq(yy_prev, yy_curr)):
break# loop AWAIT
return (yy_curr)
def cossin_ev(init_ii, xx_rad, addone_mult):
if (iszero(xx_rad)):
trig_sum = 0.0
else:
xr_rad = fmods(xx_rad, TAU)
xr_sqr = -xr_rad * xr_rad
cval = 1.0
ii = init_ii
while (DBLEPS / 16.0 < math.fabs(cval)):
ii += 2
cval *= xr_sqr / (ii * (ii - 1.0))
trig_sum = 1.0 / (ii * (ii + 1.0))
while (1 < ii):
trig_sum += 1.0
trig_sum *= xr_sqr / (ii * (ii - 1.0))
ii -= 2
if (addone_mult):
trig_sum += 1.0
trig_sum *= xr_rad
return (trig_sum)
def cos__1(xx_rad):
return (cossin_ev(0, xx_rad, False) + 1.0)
def cosm1__1(xx_rad):
return (cossin_ev(0, xx_rad, False))
def sin__1(xx_rad):
return (cossin_ev(1, xx_rad, True))
def sinc__1(xx_rad):
if (iszero(xx_rad)):
retvalu = 1.0
else:
if (TAU / 2.0 < math.fabs(xx_rad)):
retvalu = cossin_ev(1, xx_rad, True) / xx_rad
else:
retvalu = cossin_ev(1, xx_rad, False) + 1.0
return (retvalu)
def exp__1(xx):
if (xx < 0.0):
axx = -xx
else:
axx = xx
squaring_count = 0
while (1.0 < axx):
axx /= 2.0
squaring_count += 1
vale = 1.0
term_count = 1
while (DBLEPS / 10.0 < vale):
term_count += 1
vale *= axx / term_count
exp_sum = 1.0 / (term_count + 1.0)
for ii in range(term_count, 0, -1):
exp_sum = 1.0 + axx * (exp_sum / ii)
if (xx < 0.0):
retvalu = 1.0 / exp_sum
else:
retvalu = exp_sum
for ii in range(1, squaring_count + 1, 1):
retvalu *= retvalu
return (retvalu)
def exp__2(xx):
if (xx < 0.0):
axx = -xx
else:
axx = xx
squaring_count = 0
while (1.0 < axx):
axx /= 2.0
squaring_count += 1
vale = 1.0
term_count = 1
while (DBLEPS / 4.0 < vale):
term_count += 1
vale *= axx / term_count
expmo_sum = 0.0
for ii in range(term_count, 0, -1):
expmo_sum = axx * (expmo_sum + 1.0) / ii
for ii in range(1, squaring_count + 1, 1):
expmo_sum *= (2.0 + expmo_sum)
if (xx < 0.0):
retvalu = 1.0 / (expmo_sum + 1.0)
else:
retvalu = expmo_sum + 1.0
return (retvalu)
def ln__1(xx):
logshift = 0.0
yy_curr = 8.0 / xx
tmp = (DBLEPS)
while (tmp < yy_curr):
logshift -= 16.0 * TWOLN
yy_curr /= 65536.0
retvalu = (PI / agmean(2.0, yy_curr) + logshift)
return (retvalu)
def ln__2(xx):
yy_curr = xx
ptwo = 0.0
while (TWOSQRT < yy_curr):
ptwo += 1.0
yy_curr /= 2.0
while (yy_curr < 1.0 / TWOSQRT):
ptwo -= 1.0
yy_curr *= 2.0
mant = (yy_curr - 1.0) / (yy_curr + 1.0)
sum_curr = 2.0 * mant
term = sum_curr
mant *= mant
nn = 3
while True:
term *= mant
sum_prev = sum_curr
sum_curr += term / nn
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
nn += 2
return (ptwo * TWOLN + sum_curr)
def euler__1():
twon = 1.0
exptwon = E
ii = 0
while True:
twon *= 2.0
exptwon *= exptwon
if (0.1 < DBLEPS * exptwon):
break# loop AWAIT
ii += 1
term = 1.0 / twon
subsum = 0.0
sum_curr = 0.0
jj = 1
while True:
subsum += 1.0 / jj
term *= twon / jj
sum_prev = sum_curr
sum_curr += term * subsum
if (iseq(sum_prev, sum_curr)):
break# loop AWAIT
jj += 1
return (twon * sum_curr / exptwon - (ii + 1.0) * TWOLN)
def sphere_d(lata_rad, lona_rad, latb_rad, lonb_rad):
c_lata = math.cos(lata_rad)
c_latb = math.cos(latb_rad)
s_lata = math.sin(lata_rad)
s_latb = math.sin(latb_rad)
s_lond = math.sin(lonb_rad - lona_rad)
c_lond = math.cos(lonb_rad - lona_rad)
xc = c_lata * s_latb - s_lata * c_latb * c_lond
xd = c_latb * s_lond
xe = s_lata * s_latb + c_lata * c_latb * c_lond
retvalu = math.atan2(hypot(xd, xc), xe)
return (retvalu)
def great_circle_distance(lata_rad, lona_rad, latb_rad, lonb_rad):
return (sphere_d(lata_rad, lona_rad, latb_rad, lonb_rad))
def sphere_distance(lata_rad, lona_rad, latb_rad, lonb_rad, ret_dirs_arr_p):
c_lata = math.cos(lata_rad)
c_latb = math.cos(latb_rad)
s_lata = math.sin(lata_rad)
s_latb = math.sin(latb_rad)
s_lond = math.sin(lonb_rad - lona_rad)
c_lond = math.cos(lonb_rad - lona_rad)
xc = c_lata * s_latb - s_lata * c_latb * c_lond
xd = c_latb * s_lond
ret_dirs_arr_p[0] = math.atan2(xd, xc)
xe = s_lata * s_latb + c_lata * c_latb * c_lond
dist = math.atan2(hypot(xd, xc), xe)
xc = c_latb * s_lata - s_latb * c_lata * c_lond
xd = c_lata * s_lond
ret_dirs_arr_p[1] = -math.atan2(xd, xc)
return (dist)
def lf_ka(usq):
hyp = math.sqrt(1.0 + usq)
return ((hyp - 1.0) / (hyp + 1.0))
def lf_cap_a(usq):
ka = lf_ka(usq)
return ((1.0 + square(ka / 2.0)) / (1.0 - ka))
def lf_cap_b(usq):
ka = lf_ka(usq)
return (ka * (1.0 - 3.0 * square(ka) / 8.0))
def ellipsoid_distance(flat, lata_rad, lona_rad, latb_rad, lonb_rad,\
ret_dirs_arr_p):
iflat = 1.0 - flat
cap_ua = math.atan2(iflat * math.sin(lata_rad), math.cos(lata_rad))
cap_ub = math.atan2(iflat * math.sin(latb_rad), math.cos(latb_rad))
lon_diff = lonb_rad - lona_rad
xx_curr = lon_diff
c_cap_ua = math.cos(cap_ua)
c_cap_ub = math.cos(cap_ub)
s_cap_ua = math.sin(cap_ua)
s_cap_ub = math.sin(cap_ub)
ii = 0
while True:
s_xx = math.sin(xx_curr)
c_xx = math.cos(xx_curr)
s_sig = hypot(c_cap_ub * s_xx, c_cap_ua * s_cap_ub - s_cap_ua *\
c_cap_ub * c_xx)
c_sig = s_cap_ua * s_cap_ub + c_cap_ua * c_cap_ub * c_xx
sig = math.atan2(s_sig, c_sig)
s_a = c_cap_ua * c_cap_ub * s_xx / s_sig
c_asq = 1.0 - square(s_a)
cbsigm = c_sig - divi(2 * s_cap_ua * s_cap_ub, c_asq, 0.0)
cap_c = ((flat / 16) * c_asq * (4.0 + flat * (4.0 - 3.0 * c_asq)))
xx_prev = xx_curr
xx_curr = (lon_diff + (1.0 - cap_c) * flat * s_a * (sig + cap_c *\
s_sig * (cbsigm + cap_c * c_sig * (2.0 * square(cbsigm) -\
1.0))))
if (10 < ii and iseq(math.fabs(xx_prev + xx_curr), TAU)):
xx_curr = TAU / 2.0
break
if (math.fabs(xx_curr - xx_prev) < 1.0E-12):
break# loop AWAIT
ii += 1
usq = c_asq * (1.0 / square(iflat) - 1.0)
cap_a = iflat * lf_cap_a(usq)
cap_b = lf_cap_b(usq)
deltasig = cap_b * s_sig * (cbsigm + 0.25 * cap_b * (c_sig * (-1.0 +\
2.0 * square(cbsigm)) - (1.0 / 6.0) * cap_b * cbsigm * (3.0 +\
4.0 * square(s_sig)) * (-3.0 + 4.0 * square(cbsigm))))
dist = cap_a * (sig - deltasig)
xc = c_cap_ua * s_cap_ub - s_cap_ua * c_cap_ub * c_xx
xd = c_cap_ub * s_xx
ret_dirs_arr_p[0] = math.atan2(xd, xc)
xc = c_cap_ub * s_cap_ua - s_cap_ub * c_cap_ua * c_xx
xd = c_cap_ua * s_xx
ret_dirs_arr_p[1] = -math.atan2(xd, xc)
return (dist)
def ellipsoid_destination(flat, lata_rad, lona_rad, heading_rad, distance\
, ret_loc_arr_p):
iflat = 1.0 - flat
aa = 1.0
bb = iflat * aa
cap_ua = math.atan2(iflat * math.sin(lata_rad), math.cos(lata_rad))
c_cap_ua = math.cos(cap_ua)
s_cap_ua = math.sin(cap_ua)
c_heading = math.cos(heading_rad)
s_heading = math.sin(heading_rad)
sig_b_rad = math.atan2(s_cap_ua, c_cap_ua * c_heading)
s_a = math.cos(cap_ua) * math.sin(heading_rad)
c_asq = 1.0 - square(s_a)
usq = c_asq * (square(aa / bb) - 1.0)
cap_a = lf_cap_a(usq)
cap_b = lf_cap_b(usq)
sig_rad_delta = 0.0
sig_rad = -10.0
while True:
sig_rad_prev = sig_rad
sig_rad = distance / (bb * cap_a) + sig_rad_delta
s_sig = math.sin(sig_rad)
c_sig = math.cos(sig_rad)
twosigm_rad = 2.0 * sig_b_rad + sig_rad
c_twosigm = math.cos(twosigm_rad)
c_twosigmsq = square(c_twosigm)
sig_rad_delta = cap_b * s_sig * (c_twosigm + 0.25 * cap_b * (c_sig\
* (2.0 * c_twosigmsq - 1.0) - (cap_b / 6.0) * c_twosigm *\
(4.0 * s_sig * s_sig - 3.0) * (4.0 * c_twosigmsq - 3.0)))
if (iseq(sig_rad, sig_rad_prev)):
break# loop AWAIT
xd = s_cap_ua * c_sig + c_cap_ua * s_sig * c_heading
xc = iflat * hypot(s_a, s_cap_ua * s_sig - c_cap_ua * c_sig * c_heading)
ret_loc_arr_p[0] = math.atan2(xd, xc)
xd = s_sig * s_heading
xc = c_cap_ua * c_sig - s_cap_ua * s_sig * c_heading
lamda = math.atan2(xd, xc)
cap_c = ((flat / 16.0) * c_asq * (4.0 + flat * (4.0 - 3.0 * c_asq)))
cap_l = lamda - (1.0 - cap_c) * flat * s_a * (sig_rad + cap_c * s_sig\
* (c_twosigm + cap_c * c_sig * (2 * c_twosigmsq - 1.0)))
ret_loc_arr_p[1] = cap_l + lona_rad
alpha_rad = fmodu(PI + math.atan2(s_a, c_cap_ua * c_sig * c_heading -\
s_cap_ua * s_sig), TAU)
return (alpha_rad)
def ellipsoid_surface(axis_a, axis_b, axis_c):
absaa = math.fabs(axis_a)
absbb = math.fabs(axis_b)
abscc = math.fabs(axis_c)
if (absaa < absbb):
kk = absaa
absaa = absbb
absbb = kk
if (absbb < abscc):
kk = abscc
abscc = absbb
absbb = kk
if (absaa < absbb):
kk = absaa
absaa = absbb
absbb = kk
if (abscc < absaa):
cosphi = (abscc / absaa)
phi_rad = cosinv(cosphi)
sinphi = math.sin(phi_rad)
kk = math.sqrt((1.0 - abscc * abscc / (absbb * absbb)) / (1.0 -\
abscc * abscc / (absaa * absaa)))
retvalu = TAU * (abscc * abscc + absaa * absbb / sinphi * (sinphi *\
sinphi * elliptic2ik(kk, phi_rad) + cosphi * cosphi *\
elliptic1ik(kk, phi_rad)))
else:
retvalu = 2.0 * TAU * absaa * absaa
return (retvalu)
def ellipsoid_volume(axis_a, axis_b, axis_c):
return (2.0 * TAU * axis_a * axis_b * axis_c / 3.0)
def shc_shftpoles2steps(shft, poles):
step_arr = [0 for ii in range(20)]
if (poles <= 0):
retvalu = 0.0
elif (shft < 0):
retvalu = 0.0
elif (16 < shft):
retvalu = 1.0E+9
elif (poles == 1):
step_arr[0] = +1.0
step_arr[1] = +8.75664018
step_arr[2] = +2.174418277E+1
step_arr[3] = +4.709615109E+1
step_arr[4] = +9.755325605E+1
step_arr[5] = +1.983575685E+2
step_arr[6] = +3.9991425188E+2
step_arr[7] = +8.0300236937E+2
step_arr[8] = +1.60916613901E+3
step_arr[9] = +3.22148750069E+3
step_arr[10] = +6.44612712926E+3
step_arr[11] = +1.289540487229E+4
step_arr[12] = +2.579395961911E+4
step_arr[13] = +5.159106828928E+4
step_arr[14] = +1.0318528839545E+5
step_arr[15] = +2.0637372529029E+5
step_arr[16] = +4.1275053067337E+5
retvalu = step_arr[shft]
elif (poles == 2):
step_arr[0] = +1.0
step_arr[1] = +1.372295755E+1
step_arr[2] = +3.383938971E+1
step_arr[3] = +7.318281398E+1
step_arr[4] = +1.5153838699E+2
step_arr[5] = +3.0810336456E+2
step_arr[6] = +6.2116437416E+2
step_arr[7] = +1.24725288016E+3
step_arr[8] = +2.49941335432E+3
step_arr[9] = +5.00372613671E+3
step_arr[10] = +1.001234749878E+4
step_arr[11] = +2.002958840334E+4
step_arr[12] = +4.006406905172E+4
step_arr[13] = +8.013303000155E+4
step_arr[14] = +1.6027095510986E+5
step_arr[15] = +3.2054680443102E+5
step_arr[16] = +6.4109851712798E+5
retvalu = step_arr[shft]
elif (poles == 3):
step_arr[0] = +1.0
step_arr[1] = +1.737173781E+1
step_arr[2] = +4.273609545E+1
step_arr[3] = +9.238532150E+1
step_arr[4] = +1.9128399554E+2
step_arr[5] = +3.8890510497E+2
step_arr[6] = +7.8406421045E+2
step_arr[7] = +1.57434201644E+3
step_arr[8] = +3.15487771808E+3
step_arr[9] = +6.31593923478E+3
step_arr[10] = +1.263805730898E+4
step_arr[11] = +2.528229097067E+4
step_arr[12] = +5.057075779500E+4
step_arr[13] = +1.0114768912723E+5
step_arr[14] = +2.0230154729287E+5
step_arr[15] = +4.0460928016924E+5
step_arr[16] = +8.0922476138170E+5
retvalu = step_arr[shft]
elif (poles == 4):
step_arr[0] = +1.0
step_arr[1] = +2.03878236E+1
step_arr[2] = +5.009900279E+1
step_arr[3] = +1.0828162825E+2
step_arr[4] = +2.2418834788E+2
step_arr[5] = +4.5579968748E+2
step_arr[6] = +9.189270663E+2
step_arr[7] = +1.84513549236E+3
step_arr[8] = +3.69752950942E+3
step_arr[9] = +7.40230620593E+3
step_arr[10] = +1.48118537839E+4
step_arr[11] = +2.963094667636E+4
step_arr[12] = +5.926913086318E+4
step_arr[13] = +1.1854549900613E+5
step_arr[14] = +2.3709822433702E+5
step_arr[15] = +4.7420371217077E+5
step_arr[16] = +9.4841452431326E+5
retvalu = step_arr[shft]
elif (poles == 5):
step_arr[0] = +1.0
step_arr[1] = +2.301559338E+1
step_arr[2] = +5.651862690E+1
step_arr[3] = +1.2214337218E+2
step_arr[4] = +2.5288215751E+2
step_arr[5] = +5.1413464355E+2
step_arr[6] = +1.03653347249E+3
step_arr[7] = +2.08127953713E+3
step_arr[8] = +4.17074621528E+3
step_arr[9] = +8.34966697295E+3
step_arr[10] = +1.670750214140E+4
step_arr[11] = +3.342316957219E+4
step_arr[12] = +6.685449836446E+4
step_arr[13] = +1.3371716646729E+5
step_arr[14] = +2.6744248565129E+5
step_arr[15] = +5.3489319815476E+5
step_arr[16] = +1.06979462735136E+6
retvalu = step_arr[shft]
else:
retvalu = 0.0
return (retvalu)
LX_SHC_SHIFTSHIFT = 3.85514
LX_SHC_STEPSHIFT = 8.5
def shc_steps2shft(steps):
return (lg(steps + LX_SHC_STEPSHIFT) - LX_SHC_SHIFTSHIFT)
def shc_steps2shftinv(shft):
return (math.pow(2.0, shft + LX_SHC_SHIFTSHIFT) - LX_SHC_STEPSHIFT)
def shc_shft2steps(shft):
return (shc_shftpoles2steps(shft, 4))
def m2k(emm):
return (math.sqrt(emm))
def k2m(ekk):
return (ekk * ekk)
def a2k(eaa):
return (math.sin(eaa))
def k2a(ekk):
return (sininv(ekk))
def a2m(eaa):
return (square(math.sin(eaa)))
def m2a(emm):
return (sininv(math.sqrt(emm)))
def m2b(emm):
return (1.0 / math.sqrt(1.0 - emm))
def b2m(ebb):
return (1.0 - 1.0 / (ebb * ebb))
def elliptic1m(emm):
aa_arr = [0 for ii in range(2)]
bb_arr = [0 for ii in range(2)]
cc_arr = [0 for ii in range(2)]
if (emm < 1.0):
retvalu = PI / (2.0 * agmean(1.0, math.sqrt(1.0 - emm)))
elif (1.0 < emm):
aa_arr[0] = 1.0
aa_arr[1] = 0.0
bb_arr[0] = 0.0
bb_arr[1] = math.sqrt(emm - 1.0)
dd = agcmean(aa_arr, bb_arr, cc_arr)
retvalu = PI / (2.0 * dd)
else:
retvalu = 20.0
return (retvalu)
def ellipticK(ekk):
return (elliptic1m(k2m(ekk)))
def elliptic1m__1(emm):
return (carlsonRF(0.0, 1.0 - emm, 1.0))
def elliptic1m__2(emm):
term = TAU / 4.0
sum_curr = 0.0
ii = 1
while True:
term *= square(emm * ii / (ii + 1.0))
sum_prev = sum_curr
sum_curr += term
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
ii += 2
return (sum_curr)
def elliptic1im(emm, circ_rad):
emmc = 1.0 - emm
if (iszero(emm)):
retvalu = circ_rad
elif (iszero(emmc)):
if (PI / 2.0 <= math.fabs(circ_rad)):
retvalu = DBLMAX
else:
retvalu = math.log(math.tan((PI / 2.0 + circ_rad) / 2.0))
else:
npihlfs = floor(circ_rad / (PI / 2.0))
if (isodd(npihlfs)):
npihlfs += 1
lcirc_rad = circ_rad
if (npihlfs == 0):
kresult = 0.0
else:
kresult = elliptic1m(emm)
lcirc_rad -= npihlfs * PI / 2.0
if (lcirc_rad < 0.0):
lcirc_rad = -lcirc_rad
signof = -1
else:
signof = 1
tt = math.tan(lcirc_rad)
ggn = math.sqrt(emmc)
skip_flag = False
if (10.0 < math.fabs(tt)):
ee = 1.0 / (ggn * tt)
if (math.fabs(ee) < 10.0):
if (npihlfs == 0):
kresult = elliptic1m(emm)
temp = kresult - elliptic1im(emm, math.atan2(ee, 1.0))
skip_flag = True
if (not skip_flag):
aan = 1.0
ii = 1
modd = 0
while True:
temp = ggn / aan
lcirc_rad += math.atan2(tt * temp, 1.0) + modd * PI
modd = floor(lcirc_rad / PI + 0.5)
tt *= (1.0 + temp) / (1.0 - temp * tt * tt)
cc = (aan - ggn) / 2.0
temp = math.sqrt(aan * ggn)
aan = (aan + ggn) / 2.0
ggn = temp
ii += ii
if (math.fabs(cc / aan) <= DBLEPS):
break# loop AWAIT
temp = (math.atan2(tt, 1.0) + modd * PI) / (ii * aan)
if (signof < 0):
temp = -temp
retvalu = temp + npihlfs * kresult
return (retvalu)
def elliptic1k(kk):
return (elliptic1m(k2m(kk)))
def elliptic1ik(kk, circ_rad):
return (elliptic1im(k2m(kk), circ_rad))
def elliptic1a(aa):
return (elliptic1m(a2m(aa)))
def elliptic1ia(aa, circ_rad):
return (elliptic1im(a2m(aa), circ_rad))
def ellipticF(ekk, circ_rad):
return (elliptic1im(k2m(ekk), circ_rad))
def elliptic1im__1(emm, circ_rad):
npihlfs = floor(circ_rad / (PI / 2.0))
if (isodd(npihlfs)):
npihlfs += 1
lcirc_rad = circ_rad
if (npihlfs == 0):
kresult = 0.0
else:
kresult = elliptic1m(emm) * npihlfs
lcirc_rad -= npihlfs * PI / 2.0
sinphi = math.sin(lcirc_rad)
return (sinphi * carlsonRF(square(math.cos(lcirc_rad)), 1.0 - emm *\
square(sinphi), 1.0) + kresult)
def elliptic2m(emm):
aemm = math.fabs(emm)
if (aemm < 1.0):
twon = 0.5
aan = 1.0
ggn = math.sqrt(1.0 - emm)
sum = 1.0 - emm / 2.0
ii = 0
while True:
twon *= 2.0
tn = aan
aan = (aan + ggn) / 2.0
ggn = math.sqrt(tn * ggn)
sum_prev = sum
sum -= twon * (aan * aan - ggn * ggn)
if (iseq(sum, sum_prev)):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
retvalu = PI * sum / (2.0 * aan)
else:
retvalu = 1.0
return (retvalu)
def ellipticE(ekk):
return (elliptic2m(k2m(ekk)))
def elliptic2m__1(emm):
return (carlsonRF(0.0, 1.0 - emm, 1.0) - emm * carlsonRD(0.0, 1.0 -\
emm, 1.0) / 3.0)
def elliptic2im(emm, circ_rad):
if (iszero(emm)):
retvalu = circ_rad
else:
emmc = 1.0 - emm
eliptwoemm = elliptic2m(emm)
npihalfs = floor(circ_rad / (PI / 2.0))
if (isodd(npihalfs)):
npihalfs += 1
lcirc_rad = circ_rad - npihalfs * PI / 2.0
if (iszero(emmc)):
retvalu = math.sin(lcirc_rad) + npihalfs * eliptwoemm
else:
if (lcirc_rad < 0.0):
lcirc_rad = -lcirc_rad
signof = -1
else:
signof = 1
tt = math.tan(lcirc_rad)
ggn = math.sqrt(emmc)
if (math.fabs(tt) < - 1):
errsum = 1.0 / (ggn * tt)
else:
errsum = 0.0
if (0.0 < math.fabs(errsum) and math.fabs(errsum) < 1000.0):
errsum = math.atan2(1.0, ggn * tt)
temp = eliptwoemm - elliptic2im(emm, errsum) + emm *\
math.sin(circ_rad) * math.sin(errsum)
else:
cc = math.sqrt(emm)
aan = 1.0
ii = 1
modd = 0
while (DBLEPS < math.fabs(cc / aan)):
temp = ggn / aan
lcirc_rad += math.atan2(tt * temp, 1.0) + modd * PI
modd = floor(lcirc_rad / PI + 0.5)
tt *= (1.0 + temp) / (1.0 - temp * tt * tt)
cc = (aan - ggn) / 2.0
temp = math.sqrt(aan * ggn)
aan = (aan + ggn) / 2.0
ggn = temp
ii += ii
errsum += cc * math.sin(lcirc_rad)
temp = errsum + eliptwoemm * (math.atan2(tt, 1.0) + modd *\
PI) / (ii * aan * elliptic1m(emm))
if (signof < 0):
temp = -temp
retvalu = temp + npihalfs * eliptwoemm
return (retvalu)
def ellipticEi(ekk, circ_rad):
return (elliptic2im(k2m(ekk), circ_rad))
def elliptic2im__1(emm, circ_rad):
npihlfs = floor(circ_rad / (PI / 2.0))
if (isodd(npihlfs)):
npihlfs += 1
lcirc_rad = circ_rad
if (npihlfs == 0):
kresult = 0.0
else:
kresult = elliptic2m(emm) * npihlfs
lcirc_rad -= npihlfs * PI / 2.0
sinphi = math.sin(lcirc_rad)
sinphisq = sinphi * sinphi
sinphicu = sinphi * sinphisq
cosphisq = square(math.cos(lcirc_rad))
argb = 1.0 - emm * sinphisq
return (sinphi * carlsonRF(cosphisq, argb, 1.0) - emm * sinphicu *\
carlsonRD(cosphisq, argb, 1.0) / 3.0 + kresult)
def elliptic2k(kk):
return (elliptic2m(k2m(kk)))
def elliptic2ik(kk, circ_rad):
return (elliptic2im(k2m(kk), circ_rad))
def elliptic2a(aa):
return (elliptic2m(a2m(aa)))
def elliptic2ia(aa, circ_rad):
return (elliptic2im(a2m(aa), circ_rad))
def elliptic3m(enn, emm):
aemm = math.fabs(emm)
if (aemm < 1.0):
aan = 1.0
ggn = math.sqrt(1.0 - emm)
if (1.0 <= math.fabs(enn)):
ppn = math.sqrt(1.0 - emm / enn)
else:
ppn = math.sqrt(1.0 - enn)
qqn = 1.0
sum = qqn
ii = 0
while True:
tpp = ppn * ppn
tag = aan * ggn
een = (tpp - tag) / (tpp + tag)
ppn = (tpp + tag) / (2.0 * ppn)
qqn = qqn * een / 2.0
aan = (aan + ggn) / 2.0
ggn = math.sqrt(tag)
sum_prev = sum
sum += qqn
if (iseq(sum, sum_prev) and iseq(aan, ggn)):
break# loop AWAIT
ii += 1
if (20 <= ii):
break# loop AWAIT
if (1.0 <= math.fabs(enn)):
tn = emm * sum / (emm - enn)
else:
tn = 2.0 + sum * enn / (1.0 - enn)
retvalu = PI * tn / (4.0 * aan)
else:
retvalu = 1.0
return (retvalu)
def elliptic3k(enn, kk):
return (elliptic3m(enn, k2m(kk)))
def elliptic3ik(enn, kk, circ_rad):
return (elliptic3im(enn, k2m(kk), circ_rad))
def elliptic3a(enn, aa):
return (elliptic3m(enn, a2m(aa)))
def elliptic3ia(enn, aa, circ_rad):
return (elliptic3im(enn, a2m(aa), circ_rad))
def ellipticP(ekk, circ_rad):
return (elliptic3m(ekk, circ_rad))
def elliptic3im(enn, emm, circ_rad):
sp = math.sin(circ_rad)
cp = math.cos(circ_rad)
spq = sp * sp
cpq = cp * cp
spm = 1.0 - emm * spq
spn = 1.0 - enn * spq
return (sp * (carlsonRF(cpq, spm, 1.0) + spq * enn * carlsonRJ(cpq,\
spm, 1.0, spn) / 3.0))
def ellipticPi(enn, ekk, circ_rad):
return (elliptic3im(enn, k2m(ekk), circ_rad))
def elliptic3m__1(enn, emm):
return (carlsonRF(0.0, 1.0 - emm, 1.0) + enn * carlsonRJ(0.0, 1.0 -\
emm, 1.0, 1.0 - enn) / 3.0)
def elliptic3im__1(enn, emm, circ_rad):
npihlfs = floor(circ_rad / (PI / 2.0))
if (isodd(npihlfs)):
npihlfs += 1
lcirc_rad = circ_rad
if (npihlfs == 0):
kresult = 0.0
else:
kresult = elliptic3m(enn, emm) * npihlfs
lcirc_rad -= npihlfs * PI / 2.0
sinphi = math.sin(lcirc_rad)
sinphisq = sinphi * sinphi
sinphicu = sinphi * sinphisq
cosphisq = square(math.cos(lcirc_rad))
argb = 1.0 - emm * sinphisq
return (kresult + sinphi * carlsonRF(cosphisq, argb, 1.0) + sinphicu *\
carlsonRJ(cosphisq, argb, 1.0, 1.0 - enn * sinphisq) * enn / 3.0)
LX_ELLIPTIC_EPS = 1.0E-9
lv_emm = -10.0
lv_elli_rad = -10.0
lv_arr_arr = [0 for ii in range(4)]
def lf_jacobiphi_0_1(emm, elli_rad):
aa_arr = [0 for ii in range(20)]
cc_arr = [0 for ii in range(20)]
ebb = math.sqrt(1.0 - emm)
aa_arr[0] = 1.0
cc_arr[0] = math.sqrt(emm)
twon = 1.0
ii = 0
while (DBLEPS < math.fabs(cc_arr[ii] / aa_arr[ii])):
if (19 - 1 < ii):
break
ai = aa_arr[ii]
ii += 1
cc_arr[ii] = (ai - ebb) / 2.0
geo_mean = math.sqrt(ai * ebb)
aa_arr[ii] = (ai + ebb) / 2.0
ebb = geo_mean
twon *= 2.0
circ_rad = twon * aa_arr[ii] * elli_rad
while (0 < ii):
ebb = cc_arr[ii] * math.sin(circ_rad) / aa_arr[ii]
circ_rad = (sininv(ebb) + circ_rad) / 2.0
ii -= 1
return (circ_rad)
def lf_cn_0_1(emm, elli_rad):
if (emm < LX_ELLIPTIC_EPS):
snx = math.sin(elli_rad)
csx = math.cos(elli_rad)
ai = emm * (elli_rad - snx * csx) / 4.0
retvalu = csx + ai * snx
elif (emm < 1.0 - LX_ELLIPTIC_EPS):
retvalu = math.cos(lf_jacobiphi_0_1(emm, elli_rad))
else:
csx = cosh(elli_rad)
if (emm < 1.0):
snx = sinh(elli_rad)
ai = (1.0 - emm) / 4.0
retvalu = 1.0 / csx - ai * (csx * snx + elli_rad)
else:
retvalu = 1.0 / csx
return (retvalu)
def lf_sn_0_1(emm, elli_rad):
if (emm < LX_ELLIPTIC_EPS):
snx = math.sin(elli_rad)
csx = math.cos(elli_rad)
ai = emm * (elli_rad - snx * csx) / 4.0
retvalu = snx - ai * csx
elif (emm < 1.0 - LX_ELLIPTIC_EPS):
retvalu = math.sin(lf_jacobiphi_0_1(emm, elli_rad))
else:
csx = cosh(elli_rad)
snx = sinh(elli_rad)
if (emm < 1.0):
ai = (1.0 - emm) / 4.0
retvalu = (snx + snx * ai - ai * elli_rad / csx) / csx
else:
retvalu = snx / csx
return (retvalu)
def lf_dn_0_1(emm, elli_rad):
if (emm < LX_ELLIPTIC_EPS):
snx = math.sin(elli_rad)
retvalu = 1.0 - emm * snx * snx / 2.0
elif (emm < 1.0 - LX_ELLIPTIC_EPS):
snx = math.sin(lf_jacobiphi_0_1(emm, elli_rad))
retvalu = sqrtx(1.0 - emm * snx * snx)
else:
csx = cosh(elli_rad)
if (emm < 1.0):
ai = (1.0 - emm) / 4.0
snx = sinh(elli_rad)
retvalu = 1.0 / csx + ai * (csx * snx + elli_rad)
else:
retvalu = 1.0 / csx
return (retvalu)
def lf_cn_gt1(emm, elli_rad):
ekk = m2k(emm)
retvalu = lf_dn_0_1(1.0 / emm, elli_rad * ekk)
return (retvalu)
def lf_sn_gt1(emm, elli_rad):
ekk = m2k(emm)
retvalu = lf_sn_0_1(1.0 / emm, elli_rad * ekk) / ekk
return (retvalu)
def lf_dn_gt1(emm, elli_rad):
ekk = m2k(emm)
retvalu = lf_cn_0_1(1.0 / emm, elli_rad * ekk)
return (retvalu)
def lf_ellpj_0_1(emm, elli_rad, ret_arr_p):
global lv_emm
global lv_elli_rad
if (emm < LX_ELLIPTIC_EPS):
snx = math.sin(elli_rad)
csx = math.cos(elli_rad)
ai = emm * (elli_rad - snx * csx) / 4.0
ret_arr_p[0] = snx - ai * csx
ret_arr_p[1] = csx + ai * snx
ret_arr_p[2] = 1.0 - emm * snx * snx / 2.0
ret_arr_p[3] = elli_rad - ai
elif (emm < 1.0 - LX_ELLIPTIC_EPS):
circ_rad = lf_jacobiphi_0_1(emm, elli_rad)
snx = math.sin(circ_rad)
ret_arr_p[0] = snx
ret_arr_p[1] = math.cos(circ_rad)
ret_arr_p[2] = sqrtx(1.0 - emm * snx * snx)
ret_arr_p[3] = circ_rad
else:
ai = (1.0 - emm) / 4.0
csx = cosh(elli_rad)
snx = tanh(elli_rad)
twon = csx * sinh(elli_rad)
ret_arr_p[0] = snx + ai * (twon - elli_rad) / (csx * csx)
ret_arr_p[3] = 2.0 * math.atan2(math.exp(elli_rad), 1.0) - PI / 2.0\
+ ai * (twon - elli_rad) / csx
ai *= snx / csx
ret_arr_p[1] = 1.0 / csx - ai * (twon - elli_rad)
ret_arr_p[2] = 1.0 / csx + ai * (twon + elli_rad)
lv_emm = emm
lv_elli_rad = elli_rad
return int(0)
def lf_ellpj(emm, elli_rad, ret_arr_p):
global lv_emm
global lv_elli_rad
junk_arr = [0 for ii in range(4)]
if (emm < 0.0):
if (emm < - 2.0):
snx = math.sin(elli_rad) + tanh(elli_rad) - lf_sn_gt1(1.0 - emm,\
elli_rad)
else:
snx = math.sin(elli_rad) + tanh(elli_rad) - lf_sn_0_1(1.0 - emm,\
elli_rad)
if (emm < - 1.0):
csx = 2.0 * math.cos(elli_rad) - lf_cn_gt1(-emm, elli_rad)
else:
csx = 2.0 * math.cos(elli_rad) - lf_cn_0_1(-emm, elli_rad)
ret_arr_p[0] = snx
ret_arr_p[1] = csx
ret_arr_p[2] = -dn(-emm, elli_rad) + 2.0
ret_arr_p[3] = math.atan2(snx, csx)
elif (emm <= 1.0):
lf_ellpj_0_1(emm, elli_rad, junk_arr)
ret_arr_p[0] = junk_arr[0]
ret_arr_p[1] = junk_arr[1]
ret_arr_p[2] = junk_arr[2]
ret_arr_p[3] = junk_arr[3]
else:
ai = m2k(emm)
lf_ellpj_0_1(1.0 / emm, elli_rad * ai, junk_arr)
ret_arr_p[0] = junk_arr[0] / ai
ret_arr_p[1] = junk_arr[2]
ret_arr_p[2] = junk_arr[1]
ret_arr_p[3] = junk_arr[3]
lv_emm = emm
lv_elli_rad = elli_rad
return int(0)
def jacobiphi(emm, elli_rad):
if (0.0 < emm and emm < 1.0):
circ_rad = lf_jacobiphi_0_1(emm, elli_rad)
else:
circ_rad = taninv(sn(emm, elli_rad) / cn(emm, elli_rad))
return (circ_rad)
def sn__1(emm, elli_rad):
global lv_emm
global lv_elli_rad
global lv_arr_arr
if (isneq(emm, lv_emm) or isneq(elli_rad, lv_elli_rad)):
lf_ellpj(emm, elli_rad, lv_arr_arr)
return (lv_arr_arr[0])
def cn__1(emm, elli_rad):
global lv_emm
global lv_elli_rad
global lv_arr_arr
if (isneq(emm, lv_emm) or isneq(elli_rad, lv_elli_rad)):
lf_ellpj(emm, elli_rad, lv_arr_arr)
return (lv_arr_arr[1])
def dn__1(emm, elli_rad):
global lv_emm
global lv_elli_rad
global lv_arr_arr
if (isneq(emm, lv_emm) or isneq(elli_rad, lv_elli_rad)):
lf_ellpj(emm, elli_rad, lv_arr_arr)
return (lv_arr_arr[2])
def dn(emm, elli_rad):
if (emm < - 1.0):
retvalu = -lf_dn_gt1(-emm, elli_rad) + 2.0
elif (emm < 0.0):
retvalu = -lf_dn_0_1(-emm, elli_rad) + 2.0
elif (emm <= 1.0):
retvalu = lf_dn_0_1(emm, elli_rad)
else:
ekk = m2k(emm)
retvalu = lf_cn_0_1(1.0 / emm, elli_rad * ekk)
return (retvalu)
def cn(emm, elli_rad):
if (emm < - 1.0):
retvalu = -lf_cn_gt1(-emm, elli_rad) + 2.0 * math.cos(elli_rad)
elif (emm < 0.0):
retvalu = -lf_cn_0_1(-emm, elli_rad) + 2.0 * math.cos(elli_rad)
elif (emm < LX_ELLIPTIC_EPS):
snx = math.sin(elli_rad)
csx = math.cos(elli_rad)
ai = emm * (elli_rad - snx * csx) / 4.0
retvalu = csx + ai * snx
elif (emm < 1.0 - LX_ELLIPTIC_EPS):
retvalu = math.cos(lf_jacobiphi_0_1(emm, elli_rad))
elif (emm <= 1.0):
ai = (1.0 - emm) / 4.0
csx = cosh(elli_rad)
snx = sinh(elli_rad)
retvalu = 1.0 / csx - ai * (csx * snx + elli_rad)
else:
ekk = m2k(emm)
retvalu = lf_dn_0_1(1.0 / emm, elli_rad * ekk)
return (retvalu)
def sn(emm, elli_rad):
if (emm < - 1.0):
retvalu = math.sin(elli_rad) + tanh(elli_rad) - lf_sn_gt1(1.0 - emm\
, elli_rad)
elif (emm < 0.0):
retvalu = math.sin(elli_rad) + tanh(elli_rad) - lf_sn_0_1(1.0 - emm\
, elli_rad)
elif (emm < LX_ELLIPTIC_EPS):
snx = math.sin(elli_rad)
csx = math.cos(elli_rad)
ai = emm * (elli_rad - snx * csx) / 4.0
retvalu = snx - ai * csx
elif (emm < 1.0 - LX_ELLIPTIC_EPS):
retvalu = math.sin(lf_jacobiphi_0_1(emm, elli_rad))
elif (emm <= 1.0):
ai = (1.0 - emm) / 4.0
csx = cosh(elli_rad)
snx = sinh(elli_rad)
retvalu = (snx + snx * ai - ai * elli_rad / csx) / csx
else:
ekk = m2k(emm)
retvalu = lf_sn_0_1(1.0 / emm, elli_rad * ekk) / ekk
return (retvalu)
def cd(emm, elli_rad):
return (cn(emm, elli_rad) / dn(emm, elli_rad))
def sd(emm, elli_rad):
return (sn(emm, elli_rad) / dn(emm, elli_rad))
def nd(emm, elli_rad):
return (1.0 / dn(emm, elli_rad))
def dc(emm, elli_rad):
return (dn(emm, elli_rad) / cn(emm, elli_rad))
def nc(emm, elli_rad):
return (1.0 / cn(emm, elli_rad))
def sc(emm, elli_rad):
return (sn(emm, elli_rad) / cn(emm, elli_rad))
def ds(emm, elli_rad):
return (dn(emm, elli_rad) / sn(emm, elli_rad))
def cs(emm, elli_rad):
return (cn(emm, elli_rad) / sn(emm, elli_rad))
def ns(emm, elli_rad):
return (1.0 / sn(emm, elli_rad))
def ell2cir(emm, elli_rad):
return (jacobiphi(emm, elli_rad))
def cir2ell(emm, circ_rad):
return (elliptic1im(emm, circ_rad))
def jacobicir(emm):
return (4.0 * elliptic2m(emm) / math.sqrt(1.0 - emm))
def nom(emm):
return (math.exp(-PI * elliptic1m(1.0 - emm) / elliptic1m(emm)))
def theta1(emm, zz):
sig = 1.0
qq = nom(emm)
sum_curr = 0.0
ang = zz
ang_inc = 2.0 * zz
enn = 0
while True:
sum_prev = sum_curr
sum_curr += sig * math.pow(qq, square(enn + 0.5)) * math.sin(ang)
ang += ang_inc
sig = -sig
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
enn += 1
return (2.0 * sum_curr)
def theta2(emm, zz):
qq = nom(emm)
sum_curr = 0.0
ang = zz
ang_inc = 2.0 * zz
enn = 0
while True:
sum_prev = sum_curr
sum_curr += math.pow(qq, square(enn + 0.5)) * math.cos(ang)
ang += ang_inc
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
enn += 1
return (2.0 * sum_curr)
def theta3(emm, zz):
qq = nom(emm)
sum_curr = 0.0
ang = 2.0 * zz
ang_inc = ang
enn = 1
while True:
sum_prev = sum_curr
sum_curr += math.pow(qq, enn * enn) * math.cos(ang)
ang += ang_inc
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
enn += 1
return (1.0 + 2.0 * sum_curr)
def theta4(emm, zz):
sig = 1.0
qq = nom(emm)
sum_curr = 0.0
ang = 2.0 * zz
ang_inc = ang
enn = 1
while True:
sum_prev = sum_curr
sum_curr += sig * math.pow(qq, enn * enn) * math.cos(ang)
ang += ang_inc
sig = -sig
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
enn += 1
return (1.0 + 2.0 * sum_curr)
def nevillethetac(emm, zz):
km = elliptic1m(emm)
qq = math.exp(-PI * elliptic1m(1.0 - emm) / km)
sum_curr = 0.0
cos_inc = PI * zz / km
cos_of = PI * zz / (2.0 * km)
enn = 0
while True:
sum_prev = sum_curr
sum_curr += math.pow(qq, enn * enn + enn) * math.cos(cos_of)
cos_of += cos_inc
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
enn += 1
return (sum_curr * math.sqrt(TAU * math.sqrt(qq / emm) / km))
def nevillethetad(emm, zz):
km = elliptic1m(emm)
qq = math.exp(-PI * elliptic1m(1.0 - emm) / km)
sum_curr = 0.0
cos_inc = PI * zz / km
cos_of = PI * zz / km
enn = 1
while True:
sum_prev = sum_curr
sum_curr += math.pow(qq, enn * enn) * math.cos(cos_of)
cos_of += cos_inc
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
enn += 1
return ((1.0 + 2.0 * sum_curr) * math.sqrt(TAU / km) / 2.0)
def nevillethetan(emm, zz):
km = elliptic1m(emm)
qq = math.exp(-PI * elliptic1m(1.0 - emm) / km)
sum_curr = 0.5
sig = -1.0
cos_inc = PI * zz / km
cos_of = PI * zz / km
enn = 1
while True:
sum_prev = sum_curr
sum_curr += sig * math.pow(qq, enn * enn) * math.cos(cos_of)
cos_of += cos_inc
sig = -sig
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
enn += 1
return (2.0 * sum_curr * math.sqrt(TAU / (km * math.sqrt(1.0 - emm)))\
/ 2.0)
def nevillethetas(emm, zz):
km = elliptic1m(emm)
qq = math.exp(-PI * elliptic1m(1.0 - emm) / km)
sum_curr = 0.0
sig = 1.0
cos_inc = PI * zz / km
cos_of = PI * zz / (2.0 * km)
enn = 0
while True:
sum_prev = sum_curr
sum_curr += sig * math.pow(qq, enn * enn + enn) * math.sin(cos_of)
sig = -sig
cos_of += cos_inc
if (iseq(sum_curr, sum_prev)):
break# loop AWAIT
enn += 1
return (sum_curr * math.sqrt(TAU * math.sqrt(qq / (emm * (1.0 - emm)))\
/ km))
def ellipsearea(semi_axis_a, semi_axis_b):
return (PI * semi_axis_a * semi_axis_b)
def ellipseecc(semi_axis_a, semi_axis_b):
return (topyh1(ratio(semi_axis_a, semi_axis_b)))
def ellipsem(semi_axis_a, semi_axis_b):
rati = ratio(semi_axis_a, semi_axis_b)
return (1.0 - rati * rati)
def ellipseflatness(semi_axis_a, semi_axis_b):
return (1.0 - ratio(semi_axis_a, semi_axis_b))
def ellipsen(semi_axis_a, semi_axis_b):
return (math.fabs(semi_axis_a - semi_axis_b) / (semi_axis_a +\
semi_axis_b))
def flat2ecc(flt):
return (math.sqrt(flt * (2.0 - flt)))
def ecc2flat(ecc):
return (1.0 - math.sqrt(1.0 - ecc * ecc))
def ellipsecir(semi_axes_a, semi_axes_b):
if (semi_axes_a < semi_axes_b):
aaa = semi_axes_b
bbb = semi_axes_a
else:
aaa = semi_axes_a
bbb = semi_axes_b
if (bbb <= math.sqrt(DBLEPS) * aaa):
retvalu = 4.0 * aaa
else:
suma = 0.0
axes_sum = aaa + bbb
pows_two = 1.0
ii = 0
while True:
temp = (aaa + bbb) / 2.0
bbb = math.sqrt(aaa * bbb)
aaa = temp
pows_two += pows_two
suma += pows_two * square(aaa - bbb)
if (iseq(aaa, bbb)):
break# loop AWAIT
ii += 1
if (30 <= ii):
break# loop AWAIT
retvalu = PI * (square(axes_sum) - suma) / (aaa + bbb)
return (retvalu)
def ellipsecir__1(semi_axis_a, semi_axis_b):
if (semi_axis_a < semi_axis_b):
major_axis = semi_axis_b
minor_axis = semi_axis_a
else:
major_axis = semi_axis_a
minor_axis = semi_axis_b
rati = minor_axis / major_axis
return (4.0 * major_axis * elliptic2m(1.0 - rati * rati))
def epdf(minvalx, maxvalx, data_num, data_arr_pc, pdf_num, ret_pdf_arr_p):
for ii in range(0, pdf_num + 0, 1):
ret_pdf_arr_p[ii] = 0.0
inc = 1.0 / data_num
gap_size = (maxvalx - minvalx) / (pdf_num - 1.0)
retvalu = 0.0
for ii in range(0, data_num + 0, 1):
if (data_arr_pc[ii] < minvalx):
ret_pdf_arr_p[0] += inc
elif (data_arr_pc[ii] < maxvalx):
indi = math.ceil((data_arr_pc[ii] - minvalx) / gap_size)
ret_pdf_arr_p[indi] += inc
else:
retvalu += inc
return (retvalu)
def ecdf(minvalx, maxvalx, data_num, data_arr_pc, pdf_num, ret_cdf_arr_p):
epdf(minvalx, maxvalx, data_num, data_arr_pc, pdf_num, ret_cdf_arr_p)
sumcurr = ret_cdf_arr_p[0]
for ii in range(1, pdf_num + 0, 1):
sumcurr += ret_cdf_arr_p[ii]
ret_cdf_arr_p[ii] = sumcurr
return (sumcurr)
def epdf2cdf(data_num, pdf_arr_pc, ret_cdf_arr_p):
sumcurr = 0.0
for ii in range(0, data_num + 0, 1):
sumcurr += pdf_arr_pc[ii]
ret_cdf_arr_p[ii] = sumcurr
return (sumcurr)
lv_search_target = 0
def search_check(gg):
global lv_search_target
if (gg < lv_search_target):
retvalu = -1
elif (lv_search_target < gg):
retvalu = 1
else:
retvalu = 0
return int(retvalu)
def search_search(gg):
global lv_search_target
lv_search_target = gg
curr = 1
for delta in range(0, INTMAX + 1, 1):
result = search_check(curr)
if (0 <= result):
break
curr += curr
if (4 <= curr):
delta = curr / 4
while (1 <= delta):
if (0 < result):
curr -= delta
elif (result < 0):
curr += delta
else:
break
result = search_check(curr)
if (delta < 2):
if (0 < result and 1 < curr):
curr -= 1
break
delta /= 2
return int(curr)
def blackbodyl(wavelen, temp_k):
if (wavelen <= 0.0 or temp_k <= 0.0):
retvalu = 0.0
else:
hc = PLANCK * LIGHT
hc_kt = hc / (BOLTZMANN * temp_k)
retvalu = 2.0 * hc * LIGHT / (math.pow(wavelen, 5) *\
(math.exp(hc_kt / wavelen) - 1.0))
return (retvalu)
def blackbodyf(wavefreq, temp_k):
if (wavefreq <= 0.0 or temp_k <= 0.0):
retvalu = 0.0
else:
h_kt = PLANCK / (BOLTZMANN * temp_k)
retvalu = 2.0 * PLANCK * math.pow(wavefreq, 3) / (math.pow(LIGHT,\
2) * (math.exp(h_kt * wavefreq) - 1.0))
return (retvalu)
def blackbodymode(temp_k):
if (temp_k <= 0.0):
retvalu = 0.0
else:
hc_kt = PLANCK * LIGHT / (BOLTZMANN * temp_k)
retvalu = hc_kt / (5.0 + wp(-5.0 * math.exp(-5.0)))
return (retvalu)
def blackbodypower(temp_k):
return (STEFAN * math.pow(temp_k, 4.0))
def bhmass_to_tempk(bhmass_kg):
return (BHMASSTEMP / bhmass_kg)
def bhtempk_to_mass(bhtemp_k):
return (BHMASSTEMP / bhtemp_k)
def bhmass_to_radius(bhmass_kg):
return (bhmass_kg / BHMASS_RADIUS)
def bhradius_to_mass(bhradius_m):
return (BHMASS_RADIUS * bhradius_m)
def bhmass_to_entropy(bhmass_kg):
return (bhmass_kg * bhmass_kg / BHMASS2_ENTROPY)
def bhentropy_to_mass(bhentropy):
return (math.sqrt(bhentropy * BHMASS2_ENTROPY))
def bhmass_to_power(bhmass_kg):
return (BHMASS2POWER / (bhmass_kg * bhmass_kg))
def bhpower_to_mass(bhpower_w):
return (math.sqrt(BHMASS2POWER / bhpower_w))
def bhmass_to_area(bhmass_kg):
return (bhmass_kg * bhmass_kg / BHMASS2_AREA)
def bharea_to_mass(bharea):
return (math.sqrt(BHMASS2_AREA * bharea))
def bhlifetime_to_mass(bhlifetime_s):
return (cbrt(BHMASS3_LIFETIME * bhlifetime_s))
def bhmass_to_lifetime(bhmass_kg):
return (bhmass_kg * bhmass_kg * bhmass_kg / BHMASS3_LIFETIME)
def bhmass_to_density(bhmass_kg):
return (bhmass_kg * bhmass_kg / BHMASS2_DENSITY)
def bhdensity_to_mass(bhdensity):
return (math.sqrt(bhdensity * BHMASS2_DENSITY))
def pendulum(len_m, ang_offset_rad, grav):
return (TAU * math.sqrt(len_m / grav) / agmean(1.0,\
math.cos(ang_offset_rad / 2.0)))
def sr_mass(velo_mps):
return (1.0 / sqrtxp1m1(-square(velo_mps / LIGHT)))
def sr_time(velo_mps):
return (sqrtxp1m1(-square(velo_mps / LIGHT)))
def gr_massgm(gm_gm, radius_m):
return (gm_gm / (radius_m * LIGHT * LIGHT))
def gr_mass(mass_kg, radius_m):
return (gr_massgm(GRAVITATION * mass_kg, radius_m))
def gr_timegm(gm_gm, radius_m):
con = 2 * gm_gm / (LIGHT * LIGHT)
return (sqrtxp1m1(-con / radius_m))
def gr_time(mass_kg, radius_m):
return (gr_timegm(GRAVITATION * mass_kg, radius_m))
def gr_timegm_dr(gm_gm, radius_m):
con = 2 * gm_gm / (LIGHT * LIGHT)
return (con / (2 * radius_m * radius_m * math.sqrt(1.0 - con / radius_m)))
def cent2ratio(cnt):
return (pow2(cnt / 1200.0))
def ratio2cent(rat):
return (lg(rat) * 1200.0)
# DDDDDDDDDDescription ################################### kw_description #
def kw_description():
return( \
" Kw Constants: AAABATTERY AAABATTERY_CHARGE AAABATTERY_ENERGY AAAB" + \
"ATTERY_VOLTAGE AABATTERY AABATTERY_CHARGE AABATTERY_ENERGY AABATTERY" + \
"_VOLTAGE ACCELERATION ACRE ACTION AH ALPHA ALPHA_ERR ALPHA_REC ALPHA" + \
"_REC_ERR ALPHASQRT AMOUNT AMP AMPERE AMU AMU_ERR ANGLE APERY ARCDEG " + \
"ARCDEGREE ARCGRAD ARCMIN ARCMINUTE ARCRADIAN ARCSEC ARCSECOND ARCTUR" + \
"N ARE AREA ASTRONOMICALUNIT ATM ATMOSPHERE ATMOSPHERE_ERR ATOMICMASS" + \
"UNIT ATOMICMASSUNIT_ERR ATTO AU AU_ERR AVOGADRO AVOGADRO_ERR AVOGADR" + \
"O_REC AVOGADRO_REC_ERR BAN BAR BARN BARREL BASEBALL_MASS BASEBALL_RA" + \
"DIUS BASKETBALL_MASS BASKETBALL_RADIUS BEKENSTEINENTROPY BEKENSTEINI" + \
"NFORMATION BHENTROPY_AREA BHMASS2_AREA BHMASS2_DENSITY BHMASS2_ENTRO" + \
"PY BHMASS2POWER BHMASS3_LIFETIME BHMASS_RADIUS BHMASSTEMP BHRADIUS2D" + \
"ENSITY BIT BLUE_ENERGY BLUE_Hz BLUE_WAVELENGTH BOLTZMANN BOLTZMANN_E" + \
"RR BOLTZMANN_REC BOLTZMANN_REC_ERR BTU BTU_IT BTU_TH BUSHEL c c_ERR " + \
"c_REC c_REC_ERR CAL CAL_IT CAL_TH CALORIE CANDELA CAPACITANCE CARAT " + \
"CARBATTERY CARBATTERY_CHARGE CARBATTERY_ENERGY CARBATTERY_VOLTAGE CB" + \
"ATTERY CBATTERY_CHARGE CBATTERY_ENERGY CBATTERY_VOLTAGE CENTI CHAIN " + \
"CHARGE CONDUCTANCE COULOMB COULOMBCONST COULOMBCONST_ERR CUP CURRENT" + \
" DALTON DALTON_ERR DAY DBATTERY DBATTERY_CHARGE DBATTERY_ENERGY DBAT" + \
"TERY_VOLTAGE DBLEPS DBLMAN DBLMAX DBLMAXLN DBLSIG DECA DECI DEGC DEG" + \
"F DEGR DENSITY DIME_DIAMETER DIME_HEIGHT DIME_MASS DISTANCE DIT DRYG" + \
"ALLON dvCs_ENERGY dvCs_ERR dvCs_Hz dvCs_WAVELENGTH E EARTH_AGE EHF_E" + \
"NERGY EHF_Hz EHF_WAVELENGTH EINSTEIN EINSTEIN_ERR ELECTRIC ELECTRIC_" + \
"ERR ELECTRON_CHARGE ELECTRON_CHARGE_ERR ELECTRON_MASSA ELECTRON_MASS" + \
"A_ERR ELECTRONVOLT ELEMENTARYCHARGE ELEMENTARYCHARGE_ERR ELEVATIONMA" + \
"X ELEVATIONMIN ENERGY EPSILON0 EPSILON0_ERR ERG EULER EUV_ENERGY EUV" + \
"_Hz EUV_WAVELENGTH eV EXA EXBI FARAD FARADAY FARADAY_ERR FARADAY_REC" + \
" FARADAY_REC_ERR FARADAYCONST FARADAYCONST_ERR FARADAYCONST_REC FARA" + \
"DAYCONST_REC_ERR FEET FEIGENBAUM FEMTO FINESTRUCTURE FINESTRUCTURE_E" + \
"RR FINESTRUCTURE_REC FINESTRUCTURE_REC_ERR FIR_ENERGY FIR_Hz FIR_WAV" + \
"ELENGTH FLICK FLOZ FLTEPS FLTMAN FLTMAX FLTSIG FOE FOOT FORCE FREQUE" + \
"NCY FT FURLONG G G_ERR GALACTICCENTER GALLON GAMMA_ENERGY GAMMA_Hz G" + \
"AMMA_WAVELENGTH GAMMAMIN GAS GAS_ERR GAS_REC GAS_REC_ERR GASCONST GA" + \
"SCONST_ERR GASCONST_REC GASCONST_REC_ERR GIANTIMPACT GIBI GIGA GOLFB" + \
"ALL_MASS GOLFBALL_RADIUS GRAD GRAIN GRAM GRAVITATION GRAVITATION_ERR" + \
" GRAVITATION_REC GRAVITATION_REC_ERR GRAVITATIONIERS GRAVITATIONNASA" + \
" GRAVITY GRAVITY_ERR GREEN_ENERGY GREEN_Hz GREEN_WAVELENGTH GYEAR GY" + \
"EAR_AT_0J2K h h_ERR h_REC h_REC_ERR HAND HART HARTLEY HBAR HBAR_ERR " + \
"HECTARE HECTO HENRY HERTZ HF_ENERGY HF_Hz HF_WAVELENGTH HI HI_ENERGY" + \
" HI_ERR HI_Hz HI_WAVELENGTH HORSE HORSEPOWER HOUR HP HPMETRIC HUBBLE" + \
" HUBBLE_ERR HUBBLERADIUS HX_ENERGY HX_Hz HX_WAVELENGTH HYDROGENLINE " + \
"HYDROGENLINE_ERR Hz INCH INDUCTANCE INHG INTMAX J2K J2KDAY JCENTURY " + \
"JDAY JDSEC_AT_0GREGORIAN JDSEC_AT_0J2K JDSEC_AT_0KWT JDSEC_AT_0UET J" + \
"EWISH_FIRST_MONTH JOSEPHSON JOSEPHSON_ERR JOULE JYEAR K_AT_0TEMPC K_" + \
"AT_0TEMPF K_AT_0TEMPR kB kB_ERR kB_REC kB_REC_ERR KCD KCD_ERR KELVIN" + \
" KG KGF KGFM kgfm_PER_lbfin KIBI KILO KILOGRAM KPGBOUNDARY KWT LB LB" + \
"F LBFFT lbfft_PER_lbfin LBFIN lbfinrpm_PER_Hp LC_CIRCLE_RADIUS LC_CI" + \
"RCLE_X LC_CIRCLE_Y LC_FACTORS_CNT LC_GD_CNT LC_GD_DAY LC_GD_DOW LC_G" + \
"D_HOUR LC_GD_JD LC_GD_MIN LC_GD_MONTH LC_GD_NUM LC_GD_SEC LC_GD_YEAR" + \
" LC_HALAQIM_PER_HOUR LC_KNUTH_ARRAY_CNT LC_KNUTH_KK_CNT LC_KNUTH_LL " + \
"LC_KNUTH_MAX LC_KNUTH_QUALITY_CNT LC_KNUTH_TT LC_MAGIC_INT LC_MAGIC_" + \
"INT_NOT LC_PARABOLA_COEFF_A LC_PARABOLA_COEFF_B LC_PARABOLA_COEFF_C " + \
"LC_PARABOLA_REAL_ROOTS LC_PARABOLA_ROOT_A LC_PARABOLA_ROOT_B LC_PARA" + \
"BOLA_X_AXIS LC_PARABOLA_Y_EXTREMA LC_STTS_CNT LC_STTS_KEY_CNT LC_STT" + \
"S_MAGIC LC_STTS_MAX LC_STTS_MEAN LC_STTS_MIN LC_STTS_MSQ LC_STTS_NUM" + \
" LC_STTSC_CNT LC_STTSC_COVAR LC_STTSC_MAGIC LC_STTSC_XX LC_STTSC_YY " + \
"LC_YEAR_PER_METONIC LENGTH LF_ENERGY LF_Hz LF_WAVELENGTH LIFE_AGE LI" + \
"GHT LIGHT_ERR LIGHT_REC LIGHT_REC_ERR LIGHTYEAR LINK LITER LITRE LUM" + \
"EN LUX LX_ELLIPTIC_EPS LX_HALAQIM LX_SHC_SHIFTSHIFT LX_SHC_STEPSHIFT" + \
" MACH MAGNETIC MAGNETIC_ERR MAGNETICFLUX MAGNETICINDUCTION MARATHON " + \
"MASS MEBI MEGA METER METRE MF_ENERGY MF_Hz MF_WAVELENGTH MICRO MICRO" + \
"WAVE_ENERGY MICROWAVE_Hz MICROWAVE_WAVELENGTH MILE MILKYWAY_AGE MILK" + \
"YWAY_DAY MILKYWAY_MASS MILKYWAY_RADIUS MILLI MINUTE MIR_ENERGY MIR_H" + \
"z MIR_WAVELENGTH MM MMHG MOLARMASS MOLARMASS_ERR MOLE MONTHS_IN_YEAR" + \
" MOON_MONTH MPH MPS MPSS MU0 MU0_ERR NANO NAT NEWTON NICKEL_DIAMETER" + \
" NICKEL_HEIGHT NICKEL_MASS NINEVOLT NINEVOLT_CHARGE NINEVOLT_ENERGY " + \
"NINEVOLT_VOLTAGE NINEVOLTBATTERY NINEVOLTBATTERY_CHARGE NINEVOLTBATT" + \
"ERY_ENERGY NINEVOLTBATTERY_VOLTAGE NIR_ENERGY NIR_Hz NIR_WAVELENGTH " + \
"Nm_PER_lbfin NPBOUNDARY NUV_ENERGY NUV_Hz NUV_WAVELENGTH OHM ORANGE_" + \
"ENERGY ORANGE_Hz ORANGE_WAVELENGTH OUNCE OZ OZFIN ozfin_PER_lbfin PA" + \
" PARSEC PEBI PECK PENNY_DIAMETER PENNY_HEIGHT PENNY_MASS PERCENT PER" + \
"MILLE PETA PHI PHONEBATTERY PHONEBATTERY_CHARGE PHONEBATTERY_ENERGY " + \
"PHONEBATTERY_VOLTAGE PI PICO PINGPONGBALL_MASS PINGPONGBALL_RADIUS P" + \
"INT PLANCK PLANCK_ERR PLANCK_REC PLANCK_REC_ERR PLANCKBAR PLANCKBAR_" + \
"ERR PLANCKCHARGE PLANCKENERGY PLANCKFREQUENCY PLANCKLENGTH PLANCKMAS" + \
"S PLANCKTEMP PLANCKTIME POINT POUND POWER PPB PPM PPQ PPT PRESSURE P" + \
"ROTON_RADIUS PROTON_RADIUS_ERR PROXIMACENTAURI PSI PTRBOUNDARY QUART" + \
" QUARTER_DIAMETER QUARTER_HEIGHT QUARTER_MASS RAD RADIAN RED_ENERGY " + \
"RED_Hz RED_WAVELENGTH RESISTANCE RPH RPM RPS RYDBERG RYDBERG_ENERGY " + \
"RYDBERG_ERR RYDBERG_Hz RYDBERG_REC RYDBERG_REC_ERR RYDBERG_WAVELENGT" + \
"H SECOND SHANNON SHF_ENERGY SHF_Hz SHF_WAVELENGTH SI16MAX SI16MIN SI" + \
"32MAX SI32MIN SIEMENS SOCCERBALL_MASS SOCCERBALL_RADIUS SOFTBALL_MAS" + \
"S SOFTBALL_RADIUS SOLARCONSTANT SOLID_ANGLE SPECIFICHEAT SPEED SPHER" + \
"ESURFACE SQDEG SQUAREDEGREE STANDARDATMOSPHERE STANDARDGRAVITY STEFA" + \
"N STEFAN_ERR STERADIAN STONE SURVEYFOOT SX_ENERGY SX_Hz SX_WAVELENGT" + \
"H SXX_ENERGY SXX_Hz SXX_WAVELENGTH TAU TBLSP TEBI TEMPERATURE TEMPF_" + \
"AT_0TEMPC TENLN TENNISBALL_MASS TENNISBALL_RADIUS TERA TESLA THF_ENE" + \
"RGY THF_Hz THF_WAVELENGTH TIME TON TONNE TORR TRJBOUNDARY TSP TT_AT_" + \
"0TAI TT_AT_0UT1 TURN TWOLN TWOSQRT UAMU UAMU_ERR UET UHF_ENERGY UHF_" + \
"Hz UHF_WAVELENGTH UI16MAX UI32MAX UNITGM UNIVERSE_AGE UNIVERSE_MASS " + \
"UNIVERSE_RADIUS UVA_ENERGY UVA_Hz UVA_WAVELENGTH UVB_ENERGY UVB_Hz U" + \
"VB_WAVELENGTH UVC_ENERGY UVC_Hz UVC_WAVELENGTH UVPV VHF_ENERGY VHF_H" + \
"z VHF_WAVELENGTH VIOLET_ENERGY VIOLET_Hz VIOLET_WAVELENGTH VISCOSITY" + \
" VOLT VOLTAGE VOLUME VONKLITZING VONKLITZING_ERR W_PER_Hp WATT WEBER" + \
" WEEK YARD YELLOW_ENERGY YELLOW_Hz YELLOW_WAVELENGTH YELLOWGREEN_ENE" + \
"RGY YELLOWGREEN_Hz YELLOWGREEN_WAVELENGTH YOBI YOCTO YOTTA ZEBI ZEPT" + \
"O ZETTA" + \
"\n" + \
" Kw 0-ary Functions: corr_new euler__1 gau_rand jd2ymdhmsinv magic" + \
"not magicset normal_rand parabola_realroots parabola_xaxis parabola_" + \
"yextrema randd stts_new timee" + \
"\n" + \
" Kw 1-ary Functions: a2k a2m abs agmean1 agmean1inv ahmean1 almean" + \
"1 amean1 aqmean1 b2m bankers bell bellx benford_rand bernoulli berno" + \
"ullid bernoullin bessI0 bessI1 bessJ0 bessJ1 bessK0 bessK1 bessY0 be" + \
"ssY1 bessY1__1 bharea_to_mass bhdensity_to_mass bhentropy_to_mass bh" + \
"lifetime_to_mass bhmass_to_area bhmass_to_density bhmass_to_entropy " + \
"bhmass_to_lifetime bhmass_to_power bhmass_to_radius bhmass_to_tempk " + \
"bhpower_to_mass bhradius_to_mass bhtempk_to_mass bits_count bits_ls1" + \
"b bits_ls1bpos bits_ms1b bits_ms1bpos bitwisenot blackbodyf_pdf blac" + \
"kbodyl_pdf blackbodymode blackbodypower cantor carmichael catalan ca" + \
"uchy_rand cbrt ceil cent2ratio chisqr_rand circle_get clip clockhour" + \
" clockmin clocksec clockstdev clocksum cnv_dbl2si16 contfra_print co" + \
"ntfrac_print contfracd_print corr_delete corr_handlex corr_handley c" + \
"orrcorr corrslope corrstderr corry0 cos cos__1 cosd cosdinv cosh cos" + \
"hinv cosintegral cosinv cosm1 cosm1__1 cost costinv cot cotd cotdinv" + \
" coth cothinv cotinv cott cottinv csc cscd cscdinv csch cschinv csci" + \
"nv csct csctinv ctz cu cube cuberoot date_easter date_pesach date_ro" + \
"sh_hashanah day2dhms day2dhmsinv day2hour deg2dms deg2rad deg2sec de" + \
"g2tur digamma digamma__1 digammainv dms2deg dms2rad doomsday ecc2fla" + \
"t Ein elliptic1a elliptic1k elliptic1m elliptic1m__1 elliptic1m__2 e" + \
"lliptic2a elliptic2k elliptic2m elliptic2m__1 ellipticE ellipticK er" + \
"f erf__1 erf__2 erf__3 erf__4 erfc erfcinv erfcx erfcxinv erfinv eta" + \
" eulerphi eulerx exp exp__1 exp__2 exp_rand expintegral1 expintegral" + \
"i expm1 fac facinv factor_print factorial factorialdouble factoriali" + \
"nv fibo fibox fiboxinv flat2ecc floor frac fubini fusc g2jewish gamm" + \
"a_rand gau_cdf gau_pdf gau_quantile gd gdinv geo_rand ghmean1 ghmean" + \
"1inv glmean1 gmean1 gqmean1 has_primitiveroot haversin heaviside her" + \
"onianmean1 hlmean1 hmean1 hn hn__1 hour2day hqmean1 hypot1 hypot1inv" + \
" id int_rand iround iseven isint isjewish8short isjewish9short isjew" + \
"ishleap isleapyear ismagic isneg isnegint isodd ispos isposint ispra" + \
"ctical isprime issquarefree iszero j2k2dow j2k2jd j2k2kwt j2k2uet j2" + \
"k2ymdhms jacobicir jd264_print jd2dow jd2j2k jd2kwt jd2uet jd2ymdhms" + \
" jewish2g jewish2jd jewish2jdx jewish_months_in_year jewish_yearleng" + \
"th k2a k2m k2tempc k2tempf k2tempr ks_a_cdf kwt2j2k kwt2jd kwt2uet l" + \
"10 lg lgamma lgamma__1 lgamma__2 lgammainv lix lixinv lmean1 ln ln1p" + \
" ln__1 ln__2 lns log log10 log2 logintegral logistic_rand lqmean1 lu" + \
"cas lucasx m2a m2b m2k mertens minkowski mobius n2primish neg nom no" + \
"rmal_cdf normal_cdf__1 normal_pdf normal_quantile normal_quantile__1" + \
" num2char_print parabola_get parabola_roots partition partitionq pcf" + \
" pfg pfl poi_rand pow10 pow2 prime0 prime1 primecount primecountx pr" + \
"imenext primenth primenth__1 primeprev primitiveroot qmean1 rad2deg " + \
"rad2dms rad2dms2 rad2sec rad2tur rand_init randl ratio2cent reci rei" + \
"mann round rto125 rtoi rtoz sba search_check search_search sec sec2d" + \
"eg sec2dhms sec2rad sec2tur secd secdinv sech sechinv secinv sect se" + \
"ctinv shc_shft2steps shc_steps2shft shc_steps2shftinv sigma0 sigma1 " + \
"sigmoid sigmoidinv sign sin sin__1 sinc sinc__1 sincc sincinv sind s" + \
"indinv sinh sinhinv sinintegral sininv sint sintinv smooth sq sqinv " + \
"sqrt sqrt__1 sqrt__2 sqrt__3 sqrtx sqrtxp1m1 square squareroot sr_ma" + \
"ss sr_time stair stts_delete stts_reset sttscount sttsmagic sttsmax " + \
"sttsmean sttsmin sttsmsq sttsspread sttsstdev sttsstdevmean sttssum " + \
"sttsvar supercatalan tan tand tandinv tanh tanhinv taninv tant tanti" + \
"nv tempc2k tempc2tempf tempf2k tempf2tempc tempr2k tgamma tgamma__1 " + \
"tgamma__2 tgamma__3 tgamma__stirling tgammadouble tgammainv topyh1 t" + \
"otient tri tri_rand triinv trip trunc tur2deg tur2rad tur2sec uet2j2" + \
"k uet2jd uet2kwt uni_rand versin wm wminv wp wpinv ymdhms2j2k ymdhms" + \
"2jd ymdhms_get zag zeta zig zigzag" + \
"\n" + \
" Kw 2-ary Functions: agmean agmean__1 agmeaninva agmeaninvg ahmean" + \
" almean amean aqmean atan2 atan2d atan2h atan2t atan2u ballot ballot" + \
"s base_out_print base_outf_print benford_cdf benford_pdf bess_jn bes" + \
"s_yn bessIn bessIn_ps bessJn bessJn_ps bessJv bessKn bessYn bessYn_p" + \
"s bessYv beta beta_rand binomial binomial_rand binomialx birthday bi" + \
"rthdayinv birthdayx bits_get bits_set bitshiftl bitshiftr bitwiseand" + \
" bitwiseor bitwisexor bkn blackbodyf blackbodyl carlsonRC cauchy_cdf" + \
" cauchy_pdf cauchy_quantile cd ceil2 chisqr_cdf chisqr_pdf cir2ell c" + \
"n cn__1 comb combination combx contraharmonic cs d1diamond_d2 d1lt_d" + \
"2 d1spiral_d2 d1ur_d2 d2diamond_d1 d2hypot_d1 d2lt_d1 d2spiral_d1 d2" + \
"ur_d1 days_in_month dc ddist dist dlog1 dn dn__1 ds ell2cir ellipsea" + \
"rea ellipsecir ellipsecir__1 ellipseecc ellipseflatness ellipsem ell" + \
"ipsen elliptic1ia elliptic1ik elliptic1im elliptic1im__1 elliptic2ia" + \
" elliptic2ik elliptic2im elliptic2im__1 elliptic3a elliptic3k ellipt" + \
"ic3m elliptic3m__1 ellipticEi ellipticF ellipticP entringer eulerian" + \
" exp_cdf exp_pdf exp_quantile expintegraln factor factorialt floor2 " + \
"fmod fmods fmodu fmody fmul gamma_cdf gamma_pdf gcd gcda geo_cdf geo" + \
"_pdf geo_quantile ghmean glmean gmean gompertz_rand gqmean gr_mass g" + \
"r_massgm gr_time gr_timegm gr_timegm_dr has_primitiveroot_f heronian" + \
"mean hlmean hmean hnm hqmean hypot int_cdf int_pdf int_quantile ints" + \
"_rand iseq isge isgt isle islt ismult ismultl isneq ispractical_f is" + \
"primitiveroot issignsame issquarefree_f isss jacobiphi jewish_monthb" + \
"egin jewish_monthlength ks_b_cdf ks_cdf ks_quantile lbeta lcam lcams" + \
" lcantim lcm lcombx ligamma ligammainv lmean logistic_cdf logistic_p" + \
"df logistic_quantile logx lpermx lqmean max2 maxabs maxabs2 maxi mb_" + \
"cdf mb_pdf mean min2 minabs minabs2 mini mobius_f mods modulo n2perm" + \
"_print nbd_rand nc nd nevillethetac nevillethetad nevillethetan nevi" + \
"llethetas ns nthroot__1 pareto_rand perm permutation permx pochhamme" + \
"r poi_cdf poi_pdf poi_quantile polya_rand polycnum polynum pow powi " + \
"prime0_f print_array qmean rand_init_array ratio repetendlen rligamm" + \
"a rms round2 rtomsd ruigamma sc sd shc_shftpoles2steps sigma sigma0_" + \
"f sigma1_f sn sn__1 spread2stdev stdev2spread stirling1 stirling2 st" + \
"ts_copy stts_downdate stts_newx stts_scale stts_shift stts_update st" + \
"ts_update2 t_cdf t_cdf__1 t_pdf t_quantile t_quantile__1 tetracnum t" + \
"etranum theta1 theta2 theta3 theta4 Tn topyh totient_f trap_rand tri" + \
"_cdf tri_pdf tri_quantile uigamma uigamma__1 uigammainv Un uni_cdf u" + \
"ni_pdf uni_quantile variance zeta_cdf zeta_pdf zipf_rand znorder zno" + \
"rder__1" + \
"\n" + \
" Kw 3-ary Functions: agcmean aghmean atothenmodp atothenmodx base_" + \
"out_fix_print beta_cdf beta_pdf beta_quantile betainc betainc__1 bin" + \
"omial_cdf binomial_pdf bits_assign bkbn cantorll cantorul cantorxx c" + \
"arlsonRD carlsonRF chebeval clip2 clip2x corr_update cossin_ev divi " + \
"dlog dlogx ellipsoid_surface ellipsoid_volume elliptic3ia elliptic3i" + \
"k elliptic3im elliptic3im__1 ellipticPi epdf2cdf f11 f_cdf f_quantil" + \
"e f_quantile__1 fibo3 fit_ls fit_ls0 fit_minmax fit_minmax0 fit_poly" + \
" fitx_minmax fmod2 fvad fvoa gompertz_cdf gompertz_pdf gompertz_quan" + \
"tile hms2day horner hypot3 ifzero isalmostequal isbetween isbetweenx" + \
" isfloorsame iswithin jewishymd2jd kevy_print loanpayment loanrate l" + \
"oanvalue maxabsoffset maxmin maxwell_boltzmann_cdf maxwell_boltzmann" + \
"_pdf maxwell_juttner_pdf minabsoffset n2comb_print n2perm nbd_cdf nb" + \
"d_pdf pareto_cdf pareto_pdf pareto_quantile pendulum pmean polya_cdf" + \
" polya_pdf pvad pvoa remquou roundy sigma_f sigmoid3 sigmoid3d stts_" + \
"updatex taninv3 trap_cdf trap_pdf trap_quantile ymd2dow ymd2doy ymd2" + \
"j2k ymd2j2k__1 ymd2jd zipf_cdf zipf_pdf zipf_quantile" + \
"\n" + \
" Kw 4-ary Functions: carlsonRJ f21 great_circle_distance n2comb sp" + \
"here_d" + \
"\n" + \
" Kw 5-ary Functions: sphere_distance" + \
"\n" + \
" Kw 6-ary Functions: circle_solve ecdf ellipsoid_destination ellip" + \
"soid_distance epdf parabola_solve stts_init stts_initx" + \
"\n"
)
def kw_desc():
return( \
" Kw Constants: AAABATTERY(_(CHARGE|ENERGY|VOLTAGE))? AABATTERY(_(C" + \
"HARGE|ENERGY|VOLTAGE))? ACCELERATION ACRE ACTION AH ALPHA(|_(ERR|REC" + \
"(_ERR)?)|SQRT) AMOUNT AMP(ERE)? AMU(_ERR)? ANGLE APERY ARC(DEG(REE)?" + \
"|GRAD|MIN(UTE)?|RADIAN|SEC(OND)?|TURN) AREA? ASTRONOMICALUNIT ATM(OS" + \
"PHERE(_ERR)?)? ATOMICMASSUNIT(_ERR)? ATTO AU AU_ERR AVOGADRO(|_(ERR|" + \
"REC(_ERR)?)) BAN BAR(N|REL)? BAS(EBALL_(MASS|RADIUS)|KETBALL_(MASS|R" + \
"ADIUS)) BEKENSTEIN(ENTROPY|INFORMATION) BHENTROPY_AREA BHMASS(2(_(AR" + \
"EA|DENSITY|ENTROPY)|POWER)|3_LIFETIME|_RADIUS|TEMP) BHRADIUS2DENSITY" + \
" BIT BLUE_(ENERGY|Hz|WAVELENGTH) BOLTZMANN(|_(ERR|REC(_ERR)?)) BTU(_" + \
"(IT|TH))? BUSHEL c c_ERR c_REC(_ERR)? CAL(_(IT|TH)|ORIE)? CANDELA CA" + \
"PACITANCE CAR(AT|BATTERY(_(CHARGE|ENERGY|VOLTAGE))?) CBATTERY(_(CHAR" + \
"GE|ENERGY|VOLTAGE))? CENTI CHA(IN|RGE) CONDUCTANCE COULOMB(CONST(_ER" + \
"R)?)? CUP CURRENT DALTON(_ERR)? DAY DBATTERY(_(CHARGE|ENERGY|VOLTAGE" + \
"))? DBL(EPS|MA(N|X(LN)?)|SIG) DEC[AI] DEG[CFR] DENSITY DIME_(DIAMETE" + \
"R|HEIGHT|MASS) DISTANCE DIT DRYGALLON dvCs_(E(NERGY|RR)|Hz|WAVELENGT" + \
"H) E EARTH_AGE EHF_(ENERGY|Hz|WAVELENGTH) EINSTEIN(_ERR)? ELE(CTR(IC" + \
"(_ERR)?|ON(_(CHARGE(_ERR)?|MASSA(_ERR)?)|VOLT))|MENTARYCHARGE(_ERR)?" + \
"|VATIONM(AX|IN)) ENERGY EPSILON0(_ERR)? ERG EULER EUV_(ENERGY|Hz|WAV" + \
"ELENGTH) eV EXA EXBI FARAD(|AY(|_(ERR|REC(_ERR)?)|CONST(|_(ERR|REC(_" + \
"ERR)?)))) FEET FEIGENBAUM FEMTO FINESTRUCTURE(|_(ERR|REC(_ERR)?)) FI" + \
"R_(ENERGY|Hz|WAVELENGTH) FLICK FLOZ FLT(EPS|MA[NX]|SIG) FOE FOOT FOR" + \
"CE FREQUENCY FT FURLONG G G_ERR GAL(ACTICCENTER|LON) GAMMA(_(ENERGY|" + \
"Hz|WAVELENGTH)|MIN) GAS(|_(ERR|REC(_ERR)?)|CONST(|_(ERR|REC(_ERR)?))" + \
") GIANTIMPACT GIBI GIGA GOLFBALL_(MASS|RADIUS) GRA(D|IN|M|VIT(ATION(" + \
"|_(ERR|REC(_ERR)?)|IERS|NASA)|Y(_ERR)?)) GREEN_(ENERGY|Hz|WAVELENGTH" + \
") GYEAR(_AT_0J2K)? h h_ERR h_REC(_ERR)? HAND HART(LEY)? HBAR(_ERR)? " + \
"HECT(ARE|O) HENRY HERTZ HF_(ENERGY|Hz|WAVELENGTH) HI HI_(E(NERGY|RR)" + \
"|Hz|WAVELENGTH) HORSE(POWER)? HOUR HP HPMETRIC HUBBLE(_ERR|RADIUS)? " + \
"HX_(ENERGY|Hz|WAVELENGTH) HYDROGENLINE(_ERR)? Hz INCH INDUCTANCE INH" + \
"G INTMAX J2K(DAY)? JCENTURY JDAY JDSEC_AT_0(GREGORIAN|J2K|KWT|UET) J" + \
"EWISH_FIRST_MONTH JOSEPHSON(_ERR)? JOULE JYEAR K_AT_0TEMP[CFR] kB kB" + \
"_(ERR|REC(_ERR)?) KCD(_ERR)? KELVIN KG KGFM? kgfm_PER_lbfin KIBI KIL" + \
"O(GRAM)? KPGBOUNDARY KWT LB LBF(FT)? lbfft_PER_lbfin LBFIN lbfinrpm_" + \
"PER_Hp LC_(CIRCLE_(RADIUS|[XY])|FACTORS_CNT|GD_(CNT|D(AY|OW)|HOUR|JD" + \
"|M(IN|ONTH)|NUM|SEC|YEAR)|HALAQIM_PER_HOUR|KNUTH_(ARRAY_CNT|KK_CNT|L" + \
"L|MAX|QUALITY_CNT|TT)|MAGIC_INT(_NOT)?|PARABOLA_(COEFF_[ABC]|R(EAL_R" + \
"OOTS|OOT_[AB])|X_AXIS|Y_EXTREMA)|STTS(_(CNT|KEY_CNT|M(A(GIC|X)|EAN|I" + \
"N|SQ)|NUM)|C_(C(NT|OVAR)|MAGIC|XX|YY))|YEAR_PER_METONIC) LENGTH LF_(" + \
"ENERGY|Hz|WAVELENGTH) LIFE_AGE LIGHT(|_(ERR|REC(_ERR)?)|YEAR) LINK L" + \
"IT(ER|RE) LUMEN LUX LX_(ELLIPTIC_EPS|HALAQIM|SHC_S(HIFTSHIFT|TEPSHIF" + \
"T)) MACH MAGNETIC(_ERR|FLUX|INDUCTION)? MARATHON MASS MEBI MEGA MET(" + \
"ER|RE) MF_(ENERGY|Hz|WAVELENGTH) MICRO(WAVE_(ENERGY|Hz|WAVELENGTH))?" + \
" MIL(E|KYWAY_(AGE|DAY|MASS|RADIUS)|LI) MINUTE MIR_(ENERGY|Hz|WAVELEN" + \
"GTH) MM MMHG MOL(ARMASS(_ERR)?|E) MONTHS_IN_YEAR MOON_MONTH MPH MPSS" + \
"? MU0(_ERR)? NANO NAT NEWTON NICKEL_(DIAMETER|HEIGHT|MASS) NINEVOLT(" + \
"|_(CHARGE|ENERGY|VOLTAGE)|BATTERY(_CHARGE|_ENERGY|_VOLTAGE)?) NIR_(E" + \
"NERGY|Hz|WAVELENGTH) Nm_PER_lbfin NPBOUNDARY NUV_(ENERGY|Hz|WAVELENG" + \
"TH) OHM ORANGE_(ENERGY|Hz|WAVELENGTH) OUNCE OZ OZFIN ozfin_PER_lbfin" + \
" PA PARSEC PEBI PECK PENNY_(DIAMETER|HEIGHT|MASS) PER(CENT|MILLE) PE" + \
"TA PHI PHONEBATTERY(_(CHARGE|ENERGY|VOLTAGE))? PI PICO PIN(GPONGBALL" + \
"_(MASS|RADIUS)|T) PLANCK(|_(ERR|REC(_ERR)?)|BAR(_ERR)?|CHARGE|ENERGY" + \
"|FREQUENCY|LENGTH|MASS|T(EMP|IME)) POINT POUND POWER PPB PPM PPQ PPT" + \
" PRESSURE PRO(TON_RADIUS(_ERR)?|XIMACENTAURI) PSI PTRBOUNDARY QUART(" + \
"ER_(DIAMETER|HEIGHT|MASS))? RAD(IAN)? RED_(ENERGY|Hz|WAVELENGTH) RES" + \
"ISTANCE RPH RPM RPS RYDBERG(|_(E(NERGY|RR)|Hz|REC(_ERR)?|WAVELENGTH)" + \
") SECOND SHANNON SHF_(ENERGY|Hz|WAVELENGTH) SI16M(AX|IN) SI32M(AX|IN" + \
") SIEMENS SOCCERBALL_(MASS|RADIUS) SOFTBALL_(MASS|RADIUS) SOL(ARCONS" + \
"TANT|ID_ANGLE) SPE(CIFICHEAT|ED) SPHERESURFACE SQDEG SQUAREDEGREE ST" + \
"ANDARD(ATMOSPHERE|GRAVITY) STE(FAN(_ERR)?|RADIAN) STONE SURVEYFOOT S" + \
"X_(ENERGY|Hz|WAVELENGTH) SXX_(ENERGY|Hz|WAVELENGTH) TAU TBLSP TEBI T" + \
"EMP(ERATURE|F_AT_0TEMPC) TEN(LN|NISBALL_(MASS|RADIUS)) TERA TESLA TH" + \
"F_(ENERGY|Hz|WAVELENGTH) TIME TON(NE)? TORR TRJBOUNDARY TSP TT_AT_0(" + \
"TAI|UT1) TURN TWO(LN|SQRT) UAMU(_ERR)? UET UHF_(ENERGY|Hz|WAVELENGTH" + \
") UI16MAX UI32MAX UNI(TGM|VERSE_(AGE|MASS|RADIUS)) UVA_(ENERGY|Hz|WA" + \
"VELENGTH) UVB_(ENERGY|Hz|WAVELENGTH) UVC_(ENERGY|Hz|WAVELENGTH) UVPV" + \
" VHF_(ENERGY|Hz|WAVELENGTH) VIOLET_(ENERGY|Hz|WAVELENGTH) VISCOSITY " + \
"VOL(T(AGE)?|UME) VONKLITZING(_ERR)? W_PER_Hp WATT WEBER WEEK YARD YE" + \
"LLOW(_(ENERGY|Hz|WAVELENGTH)|GREEN_(ENERGY|Hz|WAVELENGTH)) YOBI YOCT" + \
"O YOTTA ZEBI ZEPTO ZETTA" + \
"\n" + \
" Kw 0-ary Functions: corr_new euler__1 gau_rand jd2ymdhmsinv magic" + \
"(not|set) normal_rand parabola_(realroots|xaxis|yextrema) randd stts" + \
"_new timee" + \
"\n" + \
" Kw 1-ary Functions: a2k a2m abs agmean1(inv)? ahmean1 almean1 ame" + \
"an1 aqmean1 b2m bankers bellx? benford_rand bernoulli[dn]? bess(I[01" + \
"]|J[01]|K[01]|Y(0|1(__1)?)) bharea_to_mass bhdensity_to_mass bhentro" + \
"py_to_mass bhlifetime_to_mass bhmass_to_(area|density|entropy|lifeti" + \
"me|power|radius|tempk) bhpower_to_mass bhradius_to_mass bhtempk_to_m" + \
"ass bit(s_(count|ls1b(pos)?|ms1b(pos)?)|wisenot) blackbody(f_pdf|l_p" + \
"df|mode|power) cantor carmichael catalan cauchy_rand cbrt ceil cent2" + \
"ratio chisqr_rand circle_get clip clock(hour|min|s(ec|tdev|um)) cnv_" + \
"dbl2si16 contfra(_print|c(_print|d_print)) corr(_(delete|handle[xy])" + \
"|corr|s(lope|tderr)|y0) cos(|__1|d(inv)?|h(inv)?|in(tegral|v)|m1(__1" + \
")?|t(inv)?) cot([dht]?(inv)?)? csc([dht]?(inv)?)? ctz cu cube(root)?" + \
" date_(easter|pesach|rosh_hashanah) day2(dhms(inv)?|hour) deg2(dms|r" + \
"ad|sec|tur) digamma(__1|inv)? dms2(deg|rad) doomsday ecc2flat Ein el" + \
"liptic(1([ak]|m(__[12])?)|2([ak]|m(__1)?)|[EK]) erf(|__([12]|[34])|c" + \
"(inv|x(inv)?)?|inv) eta euler(phi|x) exp(_(_[12]|rand)|integral[1i]|" + \
"m1)? fac(|inv|tor(_print|ial(double|inv)?)) fibo(x(inv)?)? flat2ecc " + \
"floor frac fubini fusc g2jewish gamma_rand gau_(cdf|pdf|quantile) gd" + \
" gdinv geo_rand ghmean1(inv)? glmean1 gmean1 gqmean1 has_primitivero" + \
"ot haversin heaviside heronianmean1 hlmean1 hmean1 hn hn__1 hour2day" + \
" hqmean1 hypot1(inv)? id int_rand iround is(even|int|jewish8short|je" + \
"wish9short|jewishleap|leapyear|magic|neg|negint|odd|pos|posint|pract" + \
"ical|prime|squarefree|zero) j2k2(dow|jd|kwt|uet|ymdhms) jacobicir jd" + \
"2(64_print|dow|j2k|kwt|uet|ymdhms) jewish(2(g|jdx?)|_(months_in_year" + \
"|yearlength)) k2a k2m k2temp[cfr] ks_a_cdf kwt2(j(2k|d)|uet) l10 lg " + \
"lgamma(__[12]|inv)? lix(inv)? lmean1 ln ln1p ln__[12] lns log(10|2|i" + \
"(ntegral|stic_rand))? lqmean1 lucasx? m2a m2b m2k mertens minkowski " + \
"mobius n2primish neg nom normal_(cdf(__1)?|pdf|quantile(__1)?) num2c" + \
"har_print par(abola_(get|roots)|titionq?) pcf pfg pfl poi_rand pow(1" + \
"0|2) prim(e([01]|countx?|n(ext|th(__1)?)|prev)|itiveroot) qmean1 rad" + \
"2(d(eg|ms2?)|sec|tur) rand(_init|l) ratio2cent reci reimann round rt" + \
"o(125|[iz]) sba search_(check|search) sec(|2(d(eg|hms)|rad|tur)|[dht" + \
"]?(inv)?) shc_s(hft2steps|teps2shft(inv)?) sig(m(a[01]|oid(inv)?)|n)" + \
" sin(|__1|c(__1|c|inv)?|d(inv)?|h(inv)?|in(tegral|v)|t(inv)?) smooth" + \
" sq sqinv sqrt(__[123]|x(p1m1)?)? square(root)? sr_(mass|time) stair" + \
" stts(_(delete|reset)|count|m(a(gic|x)|ean|in|sq)|s(pread|tdev(mean)" + \
"?|um)|var) supercatalan tan([dht]?(inv)?)? temp(c2(k|tempf)|f2(k|tem" + \
"pc)|r2k) tgamma(__([123]|stirling)|double|inv)? topyh1 totient tri(_" + \
"rand|inv|p)? trunc tur2(deg|rad|sec) uet2(j(2k|d)|kwt) uni_rand vers" + \
"in wm(inv)? wp(inv)? ymdhms(2j(2k|d)|_get) zag zeta zig(zag)?" + \
"\n" + \
" Kw 2-ary Functions: agmean(__1|inv[ag])? ahmean almean amean aqme" + \
"an atan2([dh]|[tu])? ballots? base_out(_print|f_print) benford_(cdf|" + \
"pdf) bess(_(jn|yn)|In(_ps)?|J(n(_ps)?|v)|Kn|Y(n(_ps)?|v)) beta(_rand" + \
")? binomial(_rand|x)? birthday(inv|x)? bit(s(_(get|set)|hift[lr])|wi" + \
"se(and|or|xor)) bkn blackbody[fl] carlsonRC cauchy_(cdf|pdf|quantile" + \
") cd ceil2 chisqr_(cdf|pdf) cir2ell cn cn__1 comb(ination|x)? contra" + \
"harmonic cs d1diamond_d2 d1lt_d2 d1spiral_d2 d1ur_d2 d2diamond_d1 d2" + \
"hypot_d1 d2lt_d1 d2spiral_d1 d2ur_d1 days_in_month dc ddist dist dlo" + \
"g1 dn dn__1 ds ell(2cir|ip(se(area|cir(__1)?|ecc|flatness|[mn])|tic(" + \
"1i([ak]|m(__1)?)|2i([ak]|m(__1)?)|3([ak]|m(__1)?)|Ei|[FP]))) entring" + \
"er eulerian exp(_(cdf|pdf|quantile)|integraln) factor(ialt)? floor2 " + \
"fmod[suy]? fmul gamma_(cdf|pdf) gcda? geo_(cdf|pdf|quantile) ghmean " + \
"glmean gmean gompertz_rand gqmean gr_(mass(gm)?|time(gm(_dr)?)?) has" + \
"_primitiveroot_f heronianmean hlmean hmean hnm hqmean hypot int(_(cd" + \
"f|pdf|quantile)|s_rand) is(eq|ge|gt|le|lt|mult|multl|neq|practical_f" + \
"|primitiveroot|signsame|squarefree_f|ss) jacobiphi jewish_month(begi" + \
"n|length) ks_(b_cdf|cdf|quantile) lbeta lca(ms?|ntim) lcm lcombx lig" + \
"amma(inv)? lmean log(istic_(cdf|pdf|quantile)|x) lpermx lqmean max(2" + \
"|abs2?|i) mb_(cdf|pdf) mean min(2|abs2?|i) mobius_f mod(s|ulo) n2per" + \
"m_print nbd_rand nc nd nevilletheta([cd]|[ns]) ns nthroot__1 pareto_" + \
"rand perm(utation|x)? pochhammer poi_(cdf|pdf|quantile) poly(a_rand|" + \
"cnum|num) powi? pri(me0_f|nt_array) qmean rand_init_array ratio repe" + \
"tendlen rligamma rms round2 rtomsd ruigamma sc sd shc_shftpoles2step" + \
"s sigma(0_f|1_f)? sn sn__1 spread2stdev stdev2spread stirling[12] st" + \
"ts_(copy|downdate|newx|s(cale|hift)|update2?) t_cdf(__1)? t_pdf t_qu" + \
"antile(__1)? tetra(cnum|num) theta([12]|[34]) Tn topyh totient_f tra" + \
"p_rand tri_(cdf|pdf|quantile) uigamma(__1|inv)? Un uni_(cdf|pdf|quan" + \
"tile) variance zeta_(cdf|pdf) zipf_rand znorder(__1)?" + \
"\n" + \
" Kw 3-ary Functions: agcmean aghmean atothenmod[px] base_out_fix_p" + \
"rint beta(_(cdf|pdf|quantile)|inc(__1)?) binomial_(cdf|pdf) bits_ass" + \
"ign bkbn cantor(ll|ul|xx) carlsonR[DF] chebeval clip2x? corr_update " + \
"cossin_ev divi dlogx? ellip(soid_(surface|volume)|tic(3i([ak]|m(__1)" + \
"?)|Pi)) epdf2cdf f11 f_cdf f_quantile(__1)? fibo3 fit(_(ls0?|minmax0" + \
"?|poly)|x_minmax) fmod2 fvad fvoa gompertz_(cdf|pdf|quantile) hms2da" + \
"y horner hypot3 ifzero is(almostequal|between|betweenx|floorsame|wit" + \
"hin) jewishymd2jd kevy_print loan(payment|rate|value) max(absoffset|" + \
"min|well_(boltzmann_(cdf|pdf)|juttner_pdf)) minabsoffset n2comb_prin" + \
"t n2perm nbd_(cdf|pdf) pareto_(cdf|pdf|quantile) pendulum pmean poly" + \
"a_(cdf|pdf) pvad pvoa remquou roundy sigm(a_f|oid3d?) stts_updatex t" + \
"aninv3 trap_(cdf|pdf|quantile) ymd2(do[wy]|j(2k(__1)?|d)) zipf_(cdf|" + \
"pdf|quantile)" + \
"\n" + \
" Kw 4-ary Functions: carlsonRJ f21 great_circle_distance n2comb sp" + \
"here_d" + \
"\n" + \
" Kw 5-ary Functions: sphere_distance" + \
"\n" + \
" Kw 6-ary Functions: circle_solve ecdf ellipsoid_d(estination|ista" + \
"nce) epdf parabola_solve stts_initx?" + \
"\n"
)
|
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 25 09:49:15 2017
@author: andre
"""
instructor = input("Enter the prof's name: ")
subject= input("Enter the subject name: ")
term = input("Enter the term: ")
format= '{} will teach {} in {} . '
print(format.format (instructor,subject,term))
|
# statistical_tests.py
# Benjamin Crestel, 2020-08-07
import numpy as np
from scipy.stats import t
def two_tailed_t_test(samples: np.ndarray, H0: float):
"""
Calculate a two-tailed t-test on the samples
null hypothesis: samples_mean = H0
:param samples: array of shape (size of each sample, number of simulations)
:param H0: value of the mean of the distribution under the null hypothesis
:return:
t_value (distribution t(df=N-1)); length 'number of simulations'
p_value (2-tailed t-test); length 'number of simulations'
"""
empirical_mean = np.mean(samples, axis=0)
number_samples = samples.shape[0]
standard_error = np.std(samples, ddof=1, axis=0) / np.sqrt(number_samples)
t_value = (empirical_mean - H0) / standard_error
p_value = 2.0 * (1.0 - t(df=number_samples - 1).cdf(np.abs(t_value)))
return t_value, p_value
def likelihood_ratio(
param: np.ndarray, likelihood: np.ndarray, param1: float, param2: float
) -> float:
"""
Calculate likelihood ratio L(theta=param1, D=D_0) / L(theta=param2, D=D_0)
:param param: array of values of parameters (parameter of the binomial)
:param likelihood: likelihood values (corresponding to the parameters)
:param param1: first parameter to test
:param param2: second paramter to test
:return: likelihood ratio
"""
index1 = np.argmin(np.abs(param - param1))
index2 = np.argmin(np.abs(param - param2))
return likelihood[index1] / likelihood[index2]
|
import numpy as np
import pandas as pd
import time
print("Reading full csv...")
overall_start = time.time()
full_tweets = pd.read_csv('corona_tweets_data.csv', error_bad_lines=False)
reading_time = time.time() - overall_start
print("Reading time: ", reading_time)
print(len(full_tweets), " tweets")
print("Filtering...")
start = time.time()
filtered = full_tweets[(~full_tweets['text'].str.startswith('RT')) & (~full_tweets['text'].str.contains('@')) & (~full_tweets['text'].str.contains('http'))]
print("Filtering time: ", time.time() - start)
print("Filtered ", len(filtered), " tweets")
print(filtered.head(10)['text'])
print("Writing to new csv...")
filtered.to_csv('filtered_tweets.csv')
print("Done: ", time.time() - overall_start)
|
import librosa
import numpy as np
import os
#pip install progressbar2
from progressbar import ProgressBar
import shutil
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg,NavigationToolbar2TkAgg
import matplotlib.backends.tkagg as tkagg
from matplotlib.backends.backend_agg import FigureCanvasAgg
from matplotlib.figure import Figure
def remove_folder(path):
# check if folder exists
if os.path.exists(path):
# remove if exists
shutil.rmtree(path)
def prepare(audio, RATE):
audio=librosa.to_mono(audio)
audio=librosa.util.fix_length(audio,RATE)
audio=librosa.util.normalize(audio)
return audio
def getFingerPrint(audio, RATE):
audio=prepare(audio,RATE)
cqt=librosa.cqt(audio,sr=RATE,hop_length=2048)
return cqt.flatten('F')
def basename(file):
file = os.path.basename(file)
return os.path.splitext(file)[0]
def removeToClose(times,tempo,spaceModificer=20):
arrayIndex=[]
for i in range(0,len(times)-1):
#tempo/20 precysion of slice ->20 bigger make more space
if times[i+1]-times[i]<(tempo/spaceModificer):
arrayIndex.append(i+1)
return np.delete(times,arrayIndex)
def moveBack(date,moveOn=0):
if(moveOn==0):
moveOn=date[0]
for i in range(0,len(date)):
date[i]=date[i]-moveOn
return date
def SliceFileOnFragments(frame,tk,NAME="",spaceModificer=20,pickExpadner=5):
remove_folder("beats")
if(NAME[-4::]!=".wav"):
NAME=NAME+".wav"
fullAudio,RATE = librosa.load(NAME)
#print(len(fullAudio)/RATE)
audioNormalizte=librosa.util.normalize(fullAudio**pickExpadner)
percusive=librosa.effects.percussive(audioNormalizte)
o_env = librosa.onset.onset_strength(percusive,sr=RATE,feature=librosa.cqt)
#print(len(o_env))
onsetFrames = librosa.onset.onset_detect(onset_envelope=o_env,sr=RATE)
tempo,timeBeats=librosa.beat.beat_track(percusive,RATE,start_bpm=60)
#print(tempo)
#print(onsetFrames)
onsetFrames=removeToClose(onsetFrames,tempo,spaceModificer)
#print(onsetFrames)
onsetFrames=moveBack(onsetFrames)
# Ta tablica interesuje mnie do MIDI
print(onsetFrames)
onsetSamples = list(librosa.frames_to_samples(onsetFrames))
#print(onsetSamples)
#for i in onsetSamples:
#print(i/RATE)
onsetSamples=np.concatenate(onsetSamples,len(fullAudio))
starts = onsetSamples[0:-1]
stops=onsetSamples[1:]
#print(starts)
#print(stops)
#print(len(onsetFrames))
clicks = librosa.core.clicks(frames=onsetFrames, sr=RATE, length=len(fullAudio))
librosa.output.write_wav("output.wav", fullAudio + clicks, RATE)
fig = Figure(facecolor='white')
axis = fig.add_subplot(111)
time_vector = np.arange(0, len(fullAudio)/RATE, 1/RATE)
axis.plot(time_vector,clicks)
axis.plot(time_vector,fullAudio)
axis.set_xlabel("Seconds")
canvas = FigureCanvasTkAgg(fig, frame)
#canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH,expand=True)
canvas.get_tk_widget().grid(column=0, row=4, columnspan=4, rowspan=4, sticky='nsew')
toolbar_frame=tk.LabelFrame(frame,text="")
toolbar_frame.grid(column=0,row=3,columnspan=4,sticky='nsew')
toolbar=NavigationToolbar2TkAgg(canvas,toolbar_frame)
frame.update()
#print(timeBeats)
#start slicing
analysisFolder="beats"
samplesFolder=os.path.join(analysisFolder,"samples")
#print(analysisFolder)
try:
os.makedirs(samplesFolder)
except:
pass
vectors = []
words = []
filenames = []
#TODO MakeProgressBar in new Window
pbar=ProgressBar()
for i,(start,stop) in enumerate(pbar(zip(starts,stops))):
audio=fullAudio[start:stop]
filename=os.path.join(samplesFolder,str(i)+".wav")
librosa.output.write_wav(filename,audio,RATE)
vector=getFingerPrint(audio,RATE)
word = basename(filename)
vectors.append(vector)
words.append(word)
filenames.append(filename)
np.savetxt(os.path.join(analysisFolder,"vectors.txt"),vectors,fmt='%.5f',delimiter='\t')
np.savetxt(os.path.join(analysisFolder,"words.txt"),words,fmt='%s')
np.savetxt(os.path.join(analysisFolder,'filenames.txt'),filenames,fmt='%s')
#canvas.show()
#SliceFileOnFragments(NAME="MonoRythm")
|
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def isUnivalTree(self, root: TreeNode) -> bool:
# dfs, check all val equal to root
return self.isUnivalTreeHelper(root, root.val)
def isUnivalTreeHelper(self, node, val):
return (
node.val == val
and (node.left is None or self.isUnivalTreeHelper(node.left, val))
and (node.right is None or self.isUnivalTreeHelper(node.right, val))
)
|
from fastapi_sqlalchemy import db
from loguru import logger
from sqlalchemy.exc import SQLAlchemyError
class ModelManagementMixin:
def save(self):
logger.info(f"Saving {self!r}")
db.session.add(self)
self._flush()
return self
def update(self, **kwargs):
for attr, value in kwargs.items():
setattr(self, attr, value)
logger.info(f"Updating {self!r} with {kwargs!r}")
return self.save()
def delete(self):
logger.info(f"Deleting {self!r}")
db.session.delete(self)
self._flush()
def _flush(self):
try:
db.session.flush()
except SQLAlchemyError as e:
logger.info(e)
db.session.rollback()
raise e
|
import time
import ctypes, sys
from Offsets import *
sys.path.insert(1, "classes/")
import pymem
import pymem.process
from features_reads import read
import features_check
import keyboard
import win32api
class rapidfire():
def __init__(self) :
read("rapid fire")
key = self.get_key()
while features_check.check.rapid_fire :
try :
read("rapid fire")
key = self.get_key()
if key :
while True :
ctypes.windll.user32.mouse_event(0x0002, 0, 0, 0, 0)
time.sleep(0.01)
ctypes.windll.user32.mouse_event(0x0004, 0, 0, 0, 0)
time.sleep(0.01)
key = self.get_key()
if not key :
break
except :
pass
def get_key(self) :
if "Button.right" in features_check.check.rapid_fire_key :
key = win32api.GetKeyState(0x02)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.left" in features_check.check.rapid_fire_key :
key = win32api.GetKeyState(0x01)
if key == -127 or key == -128 :
key = True
else :
key = False
elif "Button.middle" in features_check.check.rapid_fire_key :
key = win32api.GetKeyState(0x04)
if key == -127 or key == -128 :
key = True
else :
key = False
else :
excpected_key = features_check.check.rapid_fire_key
excpected_key = excpected_key.replace("Key.", "")
key = keyboard.is_pressed(excpected_key)
return key |
result=int(0);
def sum(i):
global result;
if(i>0):
remainder=int(i%10);
result=result+remainder;
sum(i/10);
return result;
def main():
i=int(input("Enter a value: "));
print("Result is: ",sum(i));
if __name__=="__main__":
main(); |
#!/usr/bin/env python3
"""
Deploy and execute a simple "standalone program" that just
returns a constant value:
AARCH64: 0x666badc0ffeed00d
ARM: 0xc0ffee
"""
import sys
from depthcharge import cmdline, log
from depthcharge.cmdline import create_depthcharge_ctx
parser = cmdline.ArgumentParser()
args = parser.parse_args()
if args.arch is None:
log.error('Target architecture must be specified.')
sys.exit(1)
elif args.arch.lower() == 'arm':
# push {lr}; ldr r0, =0xc0ffee; pop {pc};
program = bytes.fromhex('04 e0 2d e5 00 00 9f e5 04 f0 9d e4 ee ff c0 00')
elif args.arch.lower() == 'aarch64':
# ldr x0, =0x666c0ffeed00d; ret;
program = bytes.fromhex('40 00 00 58 c0 03 5f d6 0d d0 ee ff c0 66 06 00')
else:
log.error("Example doesn't support arch: " + args.arch)
sys.exit(1)
ctx = create_depthcharge_ctx(args)
ctx.register_payload('test_code', program)
ctx.deploy_payload('test_code')
(retval, _) = ctx.execute_payload('test_code')
log.info('Got return value: 0x{:x}'.format(retval))
|
# -*- coding: utf-8 -*-
"""
Created on Fri Apr 3 13:01:14 2020
@author: ADubey4
"""
import onnx
model = onnx.load(".\model\model.onnx")
onnx.checker.check_model(model)
onnx.helper.printable_graph(model.graph) # to check in python console
input_node = model.graph.input[0]
print(input_node.type.tensor_type)
|
import entropy._entropy as _entropy
def entropy(data):
"""Compute the Shannon entropy of the given string.
Returns a floating point value indicating how many bits of entropy
there are per octet in the string."""
return _entropy.shannon_entropy(data)
def absolute_entropy(data):
"""Compute the "absolute" entropy of the given string.
The absolute entropy of a string is how many bits of information,
total, are in the entire string. This is the same as the Shannon entropy
multiplied by the length of the string.
A string can be losslessly compressed to a size no smaller than its
absolute entropy."""
return entropy(data) * len(data)
def relative_entropy(data):
"""Compute the relative entropy of the given string.
The relative entropy is the ratio of the entropy of a string to its size,
i.e., a measure of how well it uses space. It is, therefore, a floating
point value on the interval (0, 1]."""
return entropy(data) / 8
if __name__ == '__main__':
print entropy('\n'.join(file(__file__)))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.